Rollback reduction of maximum load factor. Now it is back to 28/32.

There was no visible improvement and potentially performance regression in the production.

PiperOrigin-RevId: 828365574
Change-Id: Id3dab84ce9a6a6c132db40f370303fee0a42ed9b

Author: goldvitaly

absl/container/internal/raw_hash_set.h

@@ -1169,32 +1169,30 @@ constexpr size_t NormalizeCapacity(size_t n) {
 }
 
 // General notes on capacity/growth methods below:
-// - We use 27/32 as maximum load factor. For 16-wide groups, that gives an
-//   average of 2.5 empty slots per group.
+// - We use 7/8th as maximum load factor. For 16-wide groups, that gives an
+//   average of two empty slots per group.
+// - For (capacity+1) >= Group::kWidth, growth is 7/8*capacity.
 // - For (capacity+1) < Group::kWidth, growth == capacity. In this case, we
 //   never need to probe (the whole table fits in one group) so we don't need a
 //   load factor less than 1.
-// - For (capacity+1) == Group::kWidth, growth is capacity - 1 since we need
-//   at least one empty slot for probing algorithm.
-// - For (capacity+1) > Group::kWidth, growth is 27/32*capacity.
 
 // Given `capacity`, applies the load factor; i.e., it returns the maximum
 // number of values we should put into the table before a resizing rehash.
 constexpr size_t CapacityToGrowth(size_t capacity) {
   ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
-  // `capacity*27/32`
+  // `capacity*7/8`
   if (Group::kWidth == 8 && capacity == 7) {
-    // formula does not work when x==7.
+    // x-x/8 does not work when x==7.
     return 6;
   }
-  return capacity - capacity / 8 - capacity / 32;
+  return capacity - capacity / 8;
 }
 
 // Given `size`, "unapplies" the load factor to find how large the capacity
 // should be to stay within the load factor.
 //
 // For size == 0, returns 0.
-// For other values, returns the same as `NormalizeCapacity(size*32/27)`.
+// For other values, returns the same as `NormalizeCapacity(size*8/7)`.
 constexpr size_t SizeToCapacity(size_t size) {
   if (size == 0) {
     return 0;
@@ -1203,10 +1201,18 @@ constexpr size_t SizeToCapacity(size_t size) {
   // Shifting right `~size_t{}` by `leading_zeros` yields
   // NormalizeCapacity(size).
   int leading_zeros = absl::countl_zero(size);
-  size_t next_capacity = ~size_t{} >> leading_zeros;
-  size_t max_size_for_next_capacity = CapacityToGrowth(next_capacity);
+  constexpr size_t kLast3Bits = size_t{7} << (sizeof(size_t) * 8 - 3);
+  // max_size_for_next_capacity = max_load_factor * next_capacity
+  //                            = (7/8) * (~size_t{} >> leading_zeros)
+  //                            = (7/8*~size_t{}) >> leading_zeros
+  //                            = kLast3Bits >> leading_zeros
+  size_t max_size_for_next_capacity = kLast3Bits >> leading_zeros;
   // Decrease shift if size is too big for the minimum capacity.
   leading_zeros -= static_cast<int>(size > max_size_for_next_capacity);
+  if constexpr (Group::kWidth == 8) {
+    // Formula doesn't work when size==7 for 8-wide groups.
+    leading_zeros -= (size == 7);
+  }
   return (~size_t{}) >> leading_zeros;
 }
 

absl/container/internal/raw_hash_set_test.cc

@@ -302,7 +302,7 @@ TEST(Util, CapacityToGrowthSmallValues) {
   }
   EXPECT_EQ(CapacityToGrowth(15), 14);
   EXPECT_EQ(CapacityToGrowth(31), 28);
-  EXPECT_EQ(CapacityToGrowth(63), 55);
+  EXPECT_EQ(CapacityToGrowth(63), 56);
 }
 
 TEST(Util, GrowthAndCapacity) {

absl/hash/hash_test.cc

@@ -1311,7 +1311,7 @@ TEST(SwisstableCollisions, LowEntropyInts) {
     for (size_t i = 0; i < 128 * 1024; ++i) {
       size_t v = absl::rotl(i, bit);
       set.insert(v);
-      ASSERT_LT(HashtableDebugAccess<decltype(set)>::GetNumProbes(set, v), 32)
+      ASSERT_LT(HashtableDebugAccess<decltype(set)>::GetNumProbes(set, v), 48)
           << bit << " " << i;
     }
   }