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

Summary:

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,14 +846,14 @@ non_fbcode_target(
     exported_deps = [
         "//third-party/fmt:fmt",
         "//xplat/folly:cpu_id",
-        "//xplat/folly:hash_spooky_hash_v2",
         "//xplat/folly:likely",
         "//xplat/folly:portability",
         "//xplat/folly:portability_constexpr",
         "//xplat/folly:traits",
         "//xplat/folly/detail:range_common",
         "//xplat/folly/detail:range_simd",
         "//xplat/folly/detail:range_sse42",
+        "//xplat/folly/hash:rapidhash",
         "//xplat/folly/lang:c_string",
         "//xplat/folly/lang:exception",
     ],
@@ -7436,7 +7436,7 @@ fbcode_target(
         ":traits",
         "//folly/detail:range_common",
         "//folly/detail:range_simd",
-        "//folly/hash:spooky_hash_v2",
+        "//folly/hash:rapidhash",
         "//folly/lang:c_string",
         "//folly/lang:exception",
         "//folly/portability:constexpr",

folly/Range.h

@@ -38,7 +38,7 @@
 #pragma once
 
 #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 +794,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.)
   //
@@ -1698,7 +1698,7 @@ struct hasher<
     // 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));
+        folly::hash::rapidhashNano(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>