cpp: Use simpler 3a + b folding in std::hash

Author: chfast

include/evmc/evmc.hpp

@@ -143,18 +143,6 @@ inline constexpr uint32_t load32le(const uint8_t* bytes) noexcept
            (uint32_t{bytes[3]} << 24);
 }
 
-namespace fnv
-{
-constexpr auto prime = 0x100000001b3;              ///< The 64-bit FNV prime number.
-constexpr auto offset_basis = 0xcbf29ce484222325;  ///< The 64-bit FNV offset basis.
-
-/// The hashing transformation for 64-bit inputs based on the FNV-1a formula.
-inline constexpr uint64_t fnv1a_by64(uint64_t h, uint64_t x) noexcept
-{
-    return (h ^ x) * prime;
-}
-}  // namespace fnv
-
 
 /// The "equal to" comparison operator for the evmc::address type.
 inline constexpr bool operator==(const address& a, const address& b) noexcept
@@ -827,31 +815,25 @@ namespace std
 template <>
 struct hash<evmc::address>
 {
-    /// Hash operator using FNV1a-based folding.
+    /// Hash operator using (3a + b) folding of the address "words".
     constexpr size_t operator()(const evmc::address& s) const noexcept
     {
         using namespace evmc;
-        using namespace fnv;
-        return static_cast<size_t>(fnv1a_by64(
-            fnv1a_by64(fnv1a_by64(fnv::offset_basis, load64le(&s.bytes[0])), load64le(&s.bytes[8])),
-            load32le(&s.bytes[16])));
+        return static_cast<size_t>(3 * (3 * load64le(&s.bytes[0]) + load64le(&s.bytes[8])) +
+                                   load32le(&s.bytes[16]));
     }
 };
 
 /// Hash operator template specialization for evmc::bytes32. Needed for unordered containers.
 template <>
 struct hash<evmc::bytes32>
 {
-    /// Hash operator using FNV1a-based folding.
+    /// Hash operator using (3a + b) folding of the bytes32 64-bit words.
     constexpr size_t operator()(const evmc::bytes32& s) const noexcept
     {
         using namespace evmc;
-        using namespace fnv;
-        return static_cast<size_t>(
-            fnv1a_by64(fnv1a_by64(fnv1a_by64(fnv1a_by64(fnv::offset_basis, load64le(&s.bytes[0])),
-                                             load64le(&s.bytes[8])),
-                                  load64le(&s.bytes[16])),
-                       load64le(&s.bytes[24])));
+        return static_cast<size_t>(3 * (3 * load64le(&s.bytes[0]) + load64le(&s.bytes[8])) +
+                                   (3 * load64le(&s.bytes[16]) + load64le(&s.bytes[24])));
     }
 };
 }  // namespace std

test/unittests/cpp_test.cpp

@@ -111,19 +111,19 @@ TEST(cpp, std_hash)
 #pragma warning(disable : 4307 /* integral constant overflow */)
 #pragma warning(disable : 4309 /* 'static_cast': truncation of constant value */)
 
-    static_assert(std::hash<evmc::address>{}({}) == static_cast<size_t>(0xd94d12186c0f2fb7), "");
-    static_assert(std::hash<evmc::bytes32>{}({}) == static_cast<size_t>(0x4d25767f9dce13f5), "");
+    static_assert(std::hash<evmc::address>{}({}) == 0, "");
+    static_assert(std::hash<evmc::bytes32>{}({}) == 0, "");
 
-    EXPECT_EQ(std::hash<evmc::address>{}({}), static_cast<size_t>(0xd94d12186c0f2fb7));
-    EXPECT_EQ(std::hash<evmc::bytes32>{}({}), static_cast<size_t>(0x4d25767f9dce13f5));
+    EXPECT_EQ(std::hash<evmc::address>{}({}), size_t{0});
+    EXPECT_EQ(std::hash<evmc::bytes32>{}({}), size_t{0});
 
     auto ea = evmc::address{};
     std::fill_n(ea.bytes, sizeof(ea), uint8_t{0xee});
-    EXPECT_EQ(std::hash<evmc::address>{}(ea), static_cast<size_t>(0x41dc0178e01b7cd9));
+    EXPECT_EQ(std::hash<evmc::address>{}(ea), static_cast<size_t>(0x3333333422222216));
 
     auto eb = evmc::bytes32{};
     std::fill_n(eb.bytes, sizeof(eb), uint8_t{0xee});
-    EXPECT_EQ(std::hash<evmc::bytes32>{}(eb), static_cast<size_t>(0xbb14e5c56b477375));
+    EXPECT_EQ(std::hash<evmc::bytes32>{}(eb), static_cast<size_t>(0xeeeeeeeeeeeeeee0));
 
 #pragma warning(pop)
 }