Remove unused utility functions/constants.

PiperOrigin-RevId: 781407993
Change-Id: I645bd61588de26aa975766f837c46a202925fb8f

Author: goldvitaly

absl/container/internal/hashtable_control_bytes.h

@@ -333,13 +333,6 @@ struct GroupSse2Impl {
         _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(ctrl, special))));
   }
 
-  // Returns the number of trailing empty or deleted elements in the group.
-  uint32_t CountLeadingEmptyOrDeleted() const {
-    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
-    return TrailingZeros(static_cast<uint32_t>(
-        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1));
-  }
-
   void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
     auto msbs = _mm_set1_epi8(static_cast<char>(-128));
     auto x126 = _mm_set1_epi8(126);
@@ -424,19 +417,6 @@ struct GroupAArch64Impl {
     return NonIterableBitMaskType(mask);
   }
 
-  uint32_t CountLeadingEmptyOrDeleted() const {
-    uint64_t mask =
-        vget_lane_u64(vreinterpret_u64_u8(vcle_s8(
-                          vdup_n_s8(static_cast<int8_t>(ctrl_t::kSentinel)),
-                          vreinterpret_s8_u8(ctrl))),
-                      0);
-    // Similar to MaskEmptyorDeleted() but we invert the logic to invert the
-    // produced bitfield. We then count number of trailing zeros.
-    // Clang and GCC optimize countr_zero to rbit+clz without any check for 0,
-    // so we should be fine.
-    return static_cast<uint32_t>(countr_zero(mask)) >> 3;
-  }
-
   void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
     uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(ctrl), 0);
     constexpr uint64_t slsbs = 0x0202020202020202ULL;
@@ -503,14 +483,6 @@ struct GroupPortableImpl {
     return NonIterableBitMaskType((~ctrl | (ctrl << 7)) & kMsbs8Bytes);
   }
 
-  uint32_t CountLeadingEmptyOrDeleted() const {
-    // ctrl | ~(ctrl >> 7) will have the lowest bit set to zero for kEmpty and
-    // kDeleted. We lower all other bits and count number of trailing zeros.
-    constexpr uint64_t bits = 0x0101010101010101ULL;
-    return static_cast<uint32_t>(countr_zero((ctrl | ~(ctrl >> 7)) & bits) >>
-                                 3);
-  }
-
   void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
     constexpr uint64_t lsbs = 0x0101010101010101ULL;
     auto x = ctrl & kMsbs8Bytes;

absl/container/internal/hashtable_control_bytes_test.cc

@@ -259,32 +259,6 @@ TYPED_TEST(GroupTest, MaskFullOrSentinel) {
   }
 }
 
-TYPED_TEST(GroupTest, CountLeadingEmptyOrDeleted) {
-  using GroupType = TypeParam;
-  const std::vector<ctrl_t> empty_examples = {ctrl_t::kEmpty, ctrl_t::kDeleted};
-  const std::vector<ctrl_t> full_examples = {
-      CtrlT(0), CtrlT(1), CtrlT(2),   CtrlT(3),
-      CtrlT(5), CtrlT(9), CtrlT(127), ctrl_t::kSentinel};
-
-  for (ctrl_t empty : empty_examples) {
-    std::vector<ctrl_t> e(GroupType::kWidth, empty);
-    EXPECT_EQ(GroupType::kWidth,
-              GroupType{e.data()}.CountLeadingEmptyOrDeleted());
-    for (ctrl_t full : full_examples) {
-      for (size_t i = 0; i != GroupType::kWidth; ++i) {
-        std::vector<ctrl_t> f(GroupType::kWidth, empty);
-        f[i] = full;
-        EXPECT_EQ(i, GroupType{f.data()}.CountLeadingEmptyOrDeleted());
-      }
-      std::vector<ctrl_t> f(GroupType::kWidth, empty);
-      f[GroupType::kWidth * 2 / 3] = full;
-      f[GroupType::kWidth / 2] = full;
-      EXPECT_EQ(GroupType::kWidth / 2,
-                GroupType{f.data()}.CountLeadingEmptyOrDeleted());
-    }
-  }
-}
-
 }  // namespace
 }  // namespace container_internal
 ABSL_NAMESPACE_END

absl/container/internal/raw_hash_set_benchmark.cc

@@ -519,17 +519,6 @@ void BM_Group_MaskNonFull(benchmark::State& state) {
 }
 BENCHMARK(BM_Group_MaskNonFull);
 
-void BM_Group_CountLeadingEmptyOrDeleted(benchmark::State& state) {
-  std::array<ctrl_t, Group::kWidth> group;
-  Iota(group.begin(), group.end(), -2);
-  Group g{group.data()};
-  for (auto _ : state) {
-    ::benchmark::DoNotOptimize(g);
-    ::benchmark::DoNotOptimize(g.CountLeadingEmptyOrDeleted());
-  }
-}
-BENCHMARK(BM_Group_CountLeadingEmptyOrDeleted);
-
 void BM_Group_MatchFirstEmptyOrDeleted(benchmark::State& state) {
   std::array<ctrl_t, Group::kWidth> group;
   Iota(group.begin(), group.end(), -2);

absl/container/internal/raw_hash_set_resize_impl.h

@@ -52,7 +52,6 @@ struct ProbedItemImpl {
   static constexpr IntType kMaxNewBits = kMaxOldBits + 1;
   static constexpr IntType kMaxNewCapacity = (IntType{1} << kMaxNewBits) - 1;
 
-  static constexpr IntType kH2Shift = (kTotalBits - kH2Bits);
   static_assert(kMaxNewBits + kMaxOldBits + kH2Bits == kTotalBits);
 
   ProbedItemImpl() = default;