Add a simple benchmark for transparent lookup in raw_hash_set.

This change adds a benchmark to measure the performance of `find` operations when using transparent hash and equality functors in `absl::raw_hash_set`.

PiperOrigin-RevId: 974726978
Change-Id: I66c9bec30384916eb509abfebf4f1fe639a1012c

absl/container/BUILD.bazel

diff --git a/absl/container/BUILD.bazel b/absl/container/BUILD.bazel
index c8eba69..99b1f53 100644
--- a/absl/container/BUILD.bazel
+++ b/absl/container/BUILD.bazel
@@ -877,6 +877,7 @@
         ":hashtable_control_bytes",
         ":raw_hash_set",
         "//absl/base:raw_logging_internal",
+        "//absl/hash",
         "//absl/random",
         "//absl/strings:str_format",
         "//absl/strings:string_view",

absl/container/internal/raw_hash_set_benchmark.cc

diff --git a/absl/container/internal/raw_hash_set_benchmark.cc b/absl/container/internal/raw_hash_set_benchmark.cc
index da6e156..58baabe 100644
--- a/absl/container/internal/raw_hash_set_benchmark.cc
+++ b/absl/container/internal/raw_hash_set_benchmark.cc
@@ -34,6 +34,7 @@
 #include "absl/container/internal/hash_function_defaults.h"
 #include "absl/container/internal/hashtable_control_bytes.h"
 #include "absl/container/internal/raw_hash_set.h"
+#include "absl/hash/hash.h"
 #include "absl/random/random.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
@@ -169,6 +170,32 @@
   using Base::Base;
 };
 
+struct MyInt {
+  int64_t value;
+};
+
+struct TransparentIntHash {
+  using is_transparent = void;
+  size_t operator()(int64_t x) const { return absl::Hash<int64_t>{}(x); }
+  size_t operator()(MyInt x) const { return absl::Hash<int64_t>{}(x.value); }
+};
+
+struct TransparentIntEq {
+  using is_transparent = void;
+  bool operator()(int64_t x, MyInt y) const { return x == y.value; }
+  bool operator()(MyInt x, MyInt y) const { return x.value == y.value; }
+  bool operator()(MyInt x, int64_t y) const { return x.value == y; }
+  bool operator()(int64_t x, int64_t y) const { return x == y; }
+};
+
+struct TransparentIntTable
+    : raw_hash_set<IntPolicy, TransparentIntHash, TransparentIntEq,
+                   std::allocator<int64_t>> {
+  using Base = typename TransparentIntTable::raw_hash_set;
+  TransparentIntTable() = default;
+  using Base::Base;
+};
+
 struct string_generator {
   template <class RNG>
   std::string operator()(RNG& rng) const {
@@ -599,6 +626,20 @@
 }
 BENCHMARK(BM_DropDeletes);
 
+void BM_TransparentFind(benchmark::State& state) {
+  TransparentIntTable table;
+  for (int i = 0; i < 10000; ++i) {
+    table.insert(i);
+  }
+  while (state.KeepRunningBatch(10000)) {
+    for (int i = 0; i < 10000; ++i) {
+      auto it = table.find(MyInt{i});
+      benchmark::DoNotOptimize(it);
+    }
+  }
+}
+BENCHMARK(BM_TransparentFind);
+
 void BM_Resize(benchmark::State& state) {
   // For now just measure a small cheap hash table since we
   // are mostly interested in the overhead of type-erasure