diff options
Diffstat (limited to 'extra/libcuckoo/libcuckoo-0.3-resize-unit-test.patch')
| -rw-r--r-- | extra/libcuckoo/libcuckoo-0.3-resize-unit-test.patch | 46 |
1 files changed, 46 insertions, 0 deletions
diff --git a/extra/libcuckoo/libcuckoo-0.3-resize-unit-test.patch b/extra/libcuckoo/libcuckoo-0.3-resize-unit-test.patch new file mode 100644 index 00000000..839f4873 --- /dev/null +++ b/extra/libcuckoo/libcuckoo-0.3-resize-unit-test.patch @@ -0,0 +1,46 @@ +diff -rauN libcuckoo-0.3/tests/unit-tests/test_resize.cc libcuckoo-0.3-resize-unit-test-patch/tests/unit-tests/test_resize.cc +--- libcuckoo-0.3/tests/unit-tests/test_resize.cc 2020-03-25 15:39:43.000000000 +0100 ++++ libcuckoo-0.3-resize-unit-test-patch/tests/unit-tests/test_resize.cc 2022-02-11 06:26:19.181932212 +0100 +@@ -1,4 +1,5 @@ + #include <array> ++#include <limits> + + #include <catch.hpp> + +@@ -45,15 +46,27 @@ + REQUIRE(UnitTestInternalAccess::reserve_calc<IntIntTable>( + 2500000 * slot_per_bucket) == 22); + +- REQUIRE(UnitTestInternalAccess::reserve_calc<IntIntTable>( +- (1ULL << 31) * slot_per_bucket) == 31); +- REQUIRE(UnitTestInternalAccess::reserve_calc<IntIntTable>( +- ((1ULL << 31) + 1) * slot_per_bucket) == 32); +- +- REQUIRE(UnitTestInternalAccess::reserve_calc<IntIntTable>( +- (1ULL << 61) * slot_per_bucket) == 61); +- REQUIRE(UnitTestInternalAccess::reserve_calc<IntIntTable>( +- ((1ULL << 61) + 1) * slot_per_bucket) == 62); ++ // The maximum number of elements we can ask to reserve without incurring ++ // rounding error when computing a number of buckets is ++ // SIZE_T_MAX-slot_per_bucket(), which will come out to int_div(SIZE_T_MAX - ++ // 1, slot_per_bucket()) buckets. ++ const size_t max_buckets = ( ++ std::numeric_limits<size_t>::max() - 1)/slot_per_bucket; ++ // Since the table is always sized in powers of two, our maximum hashpower ++ // comes out to max_hashpower = floor(log2(max_buckets)). We compute this in ++ // a numerically-stable fashion. ++ size_t max_hashpower = 0; ++ for (; (static_cast<size_t>(1) << (max_hashpower + 1)) <= max_buckets; ++max_hashpower); ++ // Test the boundary between max_hashpower-1 and max_hashpower. ++ const size_t max_elems_before_max_hashpower = ( ++ static_cast<size_t>(1) << (max_hashpower - 1)) * slot_per_bucket; ++ REQUIRE(UnitTestInternalAccess::reserve_calc<IntIntTable>( ++ max_elems_before_max_hashpower) == (max_hashpower - 1)); ++ REQUIRE(UnitTestInternalAccess::reserve_calc<IntIntTable>( ++ max_elems_before_max_hashpower + 1) == max_hashpower); ++ // Test the maximum number of elements. ++ const size_t max_elems = (static_cast<size_t>(1) << max_hashpower) * slot_per_bucket; ++ REQUIRE(UnitTestInternalAccess::reserve_calc<IntIntTable>(max_elems) == max_hashpower); + } + + struct my_type { |