Rename policy.transfer to policy.transfer_n.

Also added `ABSL_PREDICT_*` to `GrowToNextCapacityAndPrepareInsert` for branches known to be common/uncommon.

PiperOrigin-RevId: 742722991
Change-Id: Ib7f30ff71adb3824752ff35e779c5fbb2d060820

Author: goldvitaly

absl/container/internal/raw_hash_set.cc

@@ -292,7 +292,7 @@ size_t DropDeletesWithoutResizeAndPrepareInsert(CommonFields& common,
   ConvertDeletedToEmptyAndFullToDeleted(ctrl, capacity);
   const void* hash_fn = policy.hash_fn(common);
   auto hasher = policy.hash_slot;
-  auto transfer = policy.transfer;
+  auto transfer_n = policy.transfer_n;
   const size_t slot_size = policy.slot_size;
 
   size_t total_probe_length = 0;
@@ -337,7 +337,7 @@ size_t DropDeletesWithoutResizeAndPrepareInsert(CommonFields& common,
       // SetCtrl poisons/unpoisons the slots so we have to call it at the
       // right time.
       SetCtrlInLargeTable(common, new_i, h2, slot_size);
-      (*transfer)(set, new_slot_ptr, slot_ptr, 1);
+      (*transfer_n)(set, new_slot_ptr, slot_ptr, 1);
       SetCtrlInLargeTable(common, i, ctrl_t::kEmpty, slot_size);
       // Initialize or change empty space id.
       tmp_space_id = i;
@@ -353,9 +353,9 @@ size_t DropDeletesWithoutResizeAndPrepareInsert(CommonFields& common,
       SanitizerUnpoisonMemoryRegion(tmp_space, slot_size);
 
       // Swap i and new_i elements.
-      (*transfer)(set, tmp_space, new_slot_ptr, 1);
-      (*transfer)(set, new_slot_ptr, slot_ptr, 1);
-      (*transfer)(set, slot_ptr, tmp_space, 1);
+      (*transfer_n)(set, tmp_space, new_slot_ptr, 1);
+      (*transfer_n)(set, new_slot_ptr, slot_ptr, 1);
+      (*transfer_n)(set, slot_ptr, tmp_space, 1);
 
       SanitizerPoisonMemoryRegion(tmp_space, slot_size);
 
@@ -623,7 +623,7 @@ void InsertOldSooSlotAndInitializeControlBytes(CommonFields& c,
   SanitizerPoisonMemoryRegion(new_slots, policy.slot_size * new_capacity);
   void* target_slot = SlotAddress(new_slots, offset, policy.slot_size);
   SanitizerUnpoisonMemoryRegion(target_slot, policy.slot_size);
-  policy.transfer(&c, target_slot, c.soo_data(), 1);
+  policy.transfer_n(&c, target_slot, c.soo_data(), 1);
   c.set_control</*kGenerateSeed=*/false>(new_ctrl);
   c.set_slots(new_slots);
   ResetCtrl(c, policy.slot_size);
@@ -863,14 +863,14 @@ size_t GrowToNextCapacityAndPrepareInsert(CommonFields& common,
     common.generate_new_seed();
     find_info = FindInfo{0, 0};
   } else {
-    if (is_single_group(new_capacity)) {
+    if (ABSL_PREDICT_TRUE(is_single_group(new_capacity))) {
       GrowIntoSingleGroupShuffleControlBytes(old_ctrl, old_capacity, new_ctrl,
                                              new_capacity);
-      // Single group tables have no deleted slots, so we can transfer all slots
-      // without checking the control bytes.
+      // Single group tables have all slots full on resize. So we can transfer
+      // all slots without checking the control bytes.
       assert(common.size() == old_capacity);
-      policy.transfer(&common, NextSlot(new_slots, slot_size), old_slots,
-                      old_capacity);
+      policy.transfer_n(&common, NextSlot(new_slots, slot_size), old_slots,
+                        old_capacity);
       PoisonEmptySlots(common, slot_size);
       // We put the new element either at the beginning or at the end of the
       // table with approximately equal probability.
@@ -895,7 +895,7 @@ size_t GrowToNextCapacityAndPrepareInsert(CommonFields& common,
   PrepareInsertCommon(common);
   ResetGrowthLeft(common);
 
-  if (has_infoz) {
+  if (ABSL_PREDICT_FALSE(has_infoz)) {
     common.set_has_infoz();
     infoz.RecordStorageChanged(common.size() - 1, new_capacity);
     infoz.RecordRehash(total_probe_length);
@@ -1083,7 +1083,7 @@ void GrowFullSooTableToNextCapacity(CommonFields& common,
     SanitizerPoisonMemoryRegion(next_slot, SooSlotMemcpySize - slot_size);
   } else {
     static_assert(SooSlotMemcpySize == 0);
-    policy.transfer(&common, target_slot, common.soo_data(), 1);
+    policy.transfer_n(&common, target_slot, common.soo_data(), 1);
   }
   common.set_control</*kGenerateSeed=*/true>(new_ctrl);
   common.set_slots(new_slots);
@@ -1134,11 +1134,11 @@ void Rehash(CommonFields& common, const PolicyFunctions& policy, size_t n) {
       assert(policy.slot_align <= alignof(HeapOrSoo));
       HeapOrSoo tmp_slot(uninitialized_tag_t{});
       size_t begin_offset = FindFirstFullSlot(0, cap, common.control());
-      policy.transfer(&common, &tmp_slot,
-                      SlotAddress(common.slot_array(), begin_offset, slot_size),
-                      1);
+      policy.transfer_n(
+          &common, &tmp_slot,
+          SlotAddress(common.slot_array(), begin_offset, slot_size), 1);
       clear_backing_array();
-      policy.transfer(&common, common.soo_data(), &tmp_slot, 1);
+      policy.transfer_n(&common, common.soo_data(), &tmp_slot, 1);
       common.set_full_soo();
       return;
     }

absl/container/internal/raw_hash_set.h

@@ -831,7 +831,7 @@ constexpr size_t NumControlBytes(size_t capacity) {
 
 // Computes the offset from the start of the backing allocation of control.
 // infoz and growth_info are stored at the beginning of the backing array.
-constexpr static size_t ControlOffset(bool has_infoz) {
+constexpr size_t ControlOffset(bool has_infoz) {
   return (has_infoz ? sizeof(HashtablezInfoHandle) : 0) + sizeof(GrowthInfo);
 }
 
@@ -1232,7 +1232,7 @@ constexpr size_t CapacityToGrowth(size_t capacity) {
 //
 // This might not be a valid capacity and `NormalizeCapacity()` should be
 // called on this.
-inline size_t GrowthToLowerboundCapacity(size_t growth) {
+constexpr size_t GrowthToLowerboundCapacity(size_t growth) {
   // `growth*8/7`
   if (Group::kWidth == 8 && growth == 7) {
     // x+(x-1)/7 does not work when x==7.
@@ -1639,8 +1639,7 @@ struct PolicyFunctions {
 
   // Transfers the contents of `count` slots from src_slot to dst_slot.
   // We use ability to transfer several slots in single group table growth.
-  // TODO(b/382423690): consider having separate `transfer` and `transfer_n`.
-  void (*transfer)(void* set, void* dst_slot, void* src_slot, size_t count);
+  void (*transfer_n)(void* set, void* dst_slot, void* src_slot, size_t count);
 
   // Returns the pointer to the CharAlloc stored in the set.
   void* (*get_char_alloc)(CommonFields& common);
@@ -1833,10 +1832,10 @@ void EraseMetaOnly(CommonFields& c, size_t index, size_t slot_size);
 // For trivially relocatable types we use memcpy directly. This allows us to
 // share the same function body for raw_hash_set instantiations that have the
 // same slot size as long as they are relocatable.
+// Separate function for relocating single slot cause significant binary bloat.
 template <size_t SizeOfSlot>
-ABSL_ATTRIBUTE_NOINLINE void TransferRelocatable(void*, void* dst, void* src,
-                                                 size_t count) {
-  // TODO(b/382423690): Experiment with transfer and transfer_n.
+ABSL_ATTRIBUTE_NOINLINE void TransferNRelocatable(void*, void* dst, void* src,
+                                                  size_t count) {
   // TODO(b/382423690): Experiment with making specialization for power of 2 and
   // non power of 2. This would require passing the size of the slot.
   memcpy(dst, src, SizeOfSlot * count);
@@ -3567,7 +3566,8 @@ class raw_hash_set {
     // TODO(b/397453582): Remove support for const hasher.
     return const_cast<std::remove_const_t<hasher>*>(&h->hash_ref());
   }
-  static void transfer_slots_fn(void* set, void* dst, void* src, size_t count) {
+  static void transfer_n_slots_fn(void* set, void* dst, void* src,
+                                  size_t count) {
     auto* src_slot = to_slot(src);
     auto* dst_slot = to_slot(dst);
 
@@ -3627,8 +3627,8 @@ class raw_hash_set {
                                 : &raw_hash_set::get_hash_ref_fn,
         PolicyTraits::template get_hash_slot_fn<hasher>(),
         PolicyTraits::transfer_uses_memcpy()
-            ? TransferRelocatable<sizeof(slot_type)>
-            : &raw_hash_set::transfer_slots_fn,
+            ? TransferNRelocatable<sizeof(slot_type)>
+            : &raw_hash_set::transfer_n_slots_fn,
         std::is_empty_v<Alloc> ? &GetRefForEmptyClass
                                : &raw_hash_set::get_char_alloc_ref_fn,
         &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,