Use rapidhashNano on folly::hasher<string/range> (facebook#2448)

Summary:
X-link: facebook/hhvm#9617

Pull Request resolved: facebook#2448

Replacing SpookyHashV2 with rapidhashNano

folly::hasher::operator() accounts for almost 3M$ in $cpu_t1_equiv_per_year_q2_2025 https://fburl.com/strobelight/izute4k3
Given that integral hashing is the identity function, most of the registered cycles should come from strings/byteRanges

See D66326393 and D75697257 for a detailed discussion around benchmarks and canaries

Differential Revision: D76052916

Author: Nicoshev

folly/BUCK

@@ -846,6 +846,7 @@ non_fbcode_target(
     exported_deps = [
         "//third-party/fmt:fmt",
         "//xplat/folly:cpu_id",
+        "//xplat/folly:hash_rapidhash",
         "//xplat/folly:hash_spooky_hash_v2",
         "//xplat/folly:likely",
         "//xplat/folly:portability",
@@ -4744,6 +4745,7 @@ non_fbcode_target(
     deps = [
         ":functional_apply_tuple",
         ":hash_murmur_hash",
+        ":hash_rapidhash",
         ":hash_spooky_hash_v1",
         ":hash_spooky_hash_v2",
         ":traits",
@@ -7419,6 +7421,7 @@ fbcode_target(
         ":traits",
         "//folly/detail:range_common",
         "//folly/detail:range_simd",
+        "//folly/hash:rapidhash",
         "//folly/hash:spooky_hash_v2",
         "//folly/lang:c_string",
         "//folly/lang:exception",

folly/Range.h

@@ -39,6 +39,7 @@
 
 #include <folly/Portability.h>
 #include <folly/hash/SpookyHashV2.h>
+#include <folly/hash/rapidhash.h>
 #include <folly/lang/CString.h>
 #include <folly/lang/Exception.h>
 #include <folly/portability/Constexpr.h>
@@ -794,7 +795,7 @@ class Range {
   }
 
   // Do NOT use this function, which was left behind for backwards
-  // compatibility.  Use SpookyHashV2 instead -- it is faster, and produces
+  // compatibility.  Use rapidhashNano instead -- it is faster, and produces
   // a 64-bit hash, which means dramatically fewer collisions in large maps.
   // (The above advice does not apply if you are targeting a 32-bit system.)
   //
@@ -1697,8 +1698,8 @@ struct hasher<
     // can contain pointers and padding.  Also, floating point numbers
     // may be == without being bit-identical.  size_t is less than 64
     // bits on some platforms.
-    return static_cast<size_t>(
-        hash::SpookyHashV2::Hash64(r.begin(), r.size() * sizeof(T), 0));
+    return static_cast<size_t>(folly::hash::rapidhashNano(
+        reinterpret_cast<const char*>(r.begin()), r.size() * sizeof(T)));
   }
 };
 

folly/hash/BUCK

@@ -47,6 +47,7 @@ fbcode_target(
     headers = ["Hash.h"],
     exported_deps = [
         ":murmur_hash",
+        ":rapidhash",
         ":spooky_hash_v1",
         ":spooky_hash_v2",
         "//folly:c_portability",

folly/hash/Hash.h

@@ -46,6 +46,7 @@
 #include <folly/hash/MurmurHash.h>
 #include <folly/hash/SpookyHashV1.h>
 #include <folly/hash/SpookyHashV2.h>
+#include <folly/hash/rapidhash.h>
 #include <folly/lang/Bits.h>
 
 namespace folly {
@@ -999,8 +1000,7 @@ struct hasher<std::string> {
   using folly_is_avalanching = std::true_type;
 
   size_t operator()(const std::string& key) const {
-    return static_cast<size_t>(
-        hash::SpookyHashV2::Hash64(key.data(), key.size(), 0));
+    return static_cast<size_t>(hash::rapidhashNano(key.data(), key.size()));
   }
 };
 template <typename K>
@@ -1011,8 +1011,7 @@ struct hasher<std::string_view> {
   using folly_is_avalanching = std::true_type;
 
   size_t operator()(const std::string_view& key) const {
-    return static_cast<size_t>(
-        hash::SpookyHashV2::Hash64(key.data(), key.size(), 0));
+    return static_cast<size_t>(hash::rapidhashNano(key.data(), key.size()));
   }
 };
 template <typename K>