From 13ecad24bec2d86896431c8e6144b7d71427bae4 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Tue, 6 Oct 2026 15:13:10 +0000 Subject: [PATCH] Remove the hashtable seed (#7871) Hashtables seed every hash with the address of a global, `ComputeSeed()`, so that ASLR varies layout and iteration order between runs. Debug builds already vary iteration order directly in `entries()`, so the seed only matters in release builds. There it costs a register and an XOR on the latency path of every integer or pointer hash, and it redraws a table's collisions in each process. Remove the seed from `HashValue`, `Hasher`, `CarbonHashValue`, `CustomHashValue::Hash`, and `HashKey`. Hashing starts from a zero buffer, so integer keys hash as `WeakMix(key)`. `global_addr_seed` remains in debug builds to seed the iteration-order entropy. `ClangDeclSignature` chained its hash through the seed, and now hashes its fields with one `Hasher`. The seed also kept some short-input paths from collapsing. Without it, every `{i, 0, 0}` array of `int32_t` hashed the same, all-zero 4-8 byte inputs lost their size, and the 17-32 byte path multiplied the size sample by a byte-shifted copy of itself. Each `Mix` operand of the short-input paths now XORs in a 32-bit constant from `ImmediateRandomData` in place of a 64-bit chunk of `StaticRandomData`, which they now only sample to encode sizes. `XorImmediate` keeps these as `xor $imm32` on x86-64; without its `asm` barrier, a read feeding the XOR is folded in instead and the constant ends up in a register that loops hoist. Cycles against trunk on Zen 5, from `bench_runner.py` with 48 runs per side, each run at a random code layout, and table sizes of 64, 3584, and 57344: - Integer and pointer hits: -3.0% to -5.7% in `Map`, -0.8% to -2.4% in `Set`. - Integer and pointer misses: up to -12.6%, except `Set` at +1.4% (64) and +6.1% (3584). - String keys: -2.8% to +2.1%, with `Map` updates at +1.1% to +1.6%. - Hash latency, without layout randomization: integers and pointers -9.8%, empty strings +5.4% (0.1 cycles), other strings not significant. Same method on an Apple M1, with #7870 on both sides. Without it, this change moves benchmark loop counters between `sp`- and `x29`-relative stack slots, which alone makes `Set` lookups up to 49% slower on the M1. - Integer and pointer hits: -1.0% to -10.3% in `Map`, -24.5% to +1.2% in `Set`. - Integer and pointer misses: -3.9% to -48.0%, except +7.2% to +59.3% at 3584, from longer probes (instructions +6.4% to +70.6%). - Inserting 64 integer keys: +12.1% to +15.0%, from store memory-order violations. - String keys: -6.6% to +3.9%. - Hash latency: integers and pointers -9.0% to -10.0%, empty strings +48.8% (1 cycle). Release builds now iterate a given table in the same order in every run. Code that depends on that order still fails in debug builds. Assisted-by: Claude Code --- common/hashing.h | 260 +++++++++++---------- common/hashing_benchmark.cpp | 10 +- common/hashing_llvm.h | 12 +- common/hashing_test.cpp | 24 +- common/hashtable_key_context.h | 21 +- common/hashtable_key_context_test.cpp | 41 ++-- common/raw_hashtable.cpp | 5 +- common/raw_hashtable.h | 30 +-- common/raw_hashtable_benchmark_helpers.cpp | 8 +- common/raw_hashtable_benchmark_helpers.h | 5 +- common/raw_hashtable_test_helpers.h | 17 +- toolchain/lex/mismatched_brackets.cpp | 4 +- toolchain/sem_ir/clang_decl.h | 21 +- toolchain/sem_ir/declared_facet_type.h | 5 +- toolchain/sem_ir/entity_name.h | 5 +- toolchain/sem_ir/inst.h | 4 +- toolchain/sem_ir/struct_type_field.h | 5 +- 17 files changed, 226 insertions(+), 251 deletions(-) diff --git a/common/hashing.h b/common/hashing.h index 3f31d85f2e2b..828e41fcd9d4 100644 --- a/common/hashing.h +++ b/common/hashing.h @@ -5,6 +5,7 @@ #ifndef CARBON_COMMON_HASHING_H_ #define CARBON_COMMON_HASHING_H_ +#include #include #include #include @@ -75,21 +76,16 @@ class HashCode : public Printable { uint64_t value_ = 0; }; -// Computes a hash code for the provided value, incorporating the provided seed. -// -// The seed doesn't need to be of any particular high quality, but a zero seed -// has bad effects in several places. Prefer the unseeded routine rather than -// providing a zero here. +// Computes a hash code for the provided value. // // This **not** a cryptographically secure or stable hash -- it is only designed // for use with in-memory hash table style data structures. Being fast and // effective for that use case is the guiding principle of its design. // -// There is no guarantee that the values produced are stable from execution to -// execution. For speed and quality reasons, the implementation does not -// introduce any variance to defend against accidental dependencies. As a -// consequence, it is strongly encouraged to use a seed that varies from -// execution to execution to avoid depending on specific values produced. +// There is no guarantee that the values produced are stable between versions +// of this code. Within one build, the hash of a value is the same in every +// execution: the function is unseeded, so hashtable layouts and collisions are +// reproducible between runs. Code must not depend on the specific values. // // The algorithm used is most heavily based on [Abseil's hashing algorithm][1], // with some additional ideas and inspiration from the fallback hashing @@ -100,13 +96,13 @@ class HashCode : public Printable { // [2]: https://github.com/tkaitchuck/aHash/wiki/AHash-fallback-algorithm // [3]: https://docs.rs/fxhash/latest/fxhash/ // -// This hash algorithm does *not* defend against hash flooding. While it can be -// viewed as "keyed" on the seed, it is expected to be possible to craft inputs -// for some data types that cancel out the seed used and manufacture endlessly -// colliding sets of keys. In general, this function works to be *fast* for hash -// tables. If you need to defend against hash flooding, either directly use a -// data structure with strong worst-case guarantees, or a hash table which -// detects catastrophic collisions and falls back to such a data structure. +// This hash algorithm does *not* defend against hash flooding. It is unkeyed, +// and it is expected to be possible to craft inputs for some data types that +// manufacture endlessly colliding sets of keys. In general, this function works +// to be *fast* for hash tables. If you need to defend against hash flooding, +// either directly use a data structure with strong worst-case guarantees, or a +// hash table which detects catastrophic collisions and falls back to such a +// data structure. // // This hash function is heavily optimized for *latency* over *quality*. Modern // hash tables designs can efficiently handle reasonable collision rates, @@ -147,7 +143,7 @@ class HashCode : public Printable { // `CarbonHashValue` with the following signature: // // ```cpp -// auto CarbonHashValue(const YourType& value, uint64_t seed) -> HashCode; +// auto CarbonHashValue(const YourType& value) -> HashCode; // ``` // // The extension point needs to ensure that values that compare equal (including @@ -173,16 +169,6 @@ class HashCode : public Printable { // // [4]: https://en.wikipedia.org/wiki/Avalanche_effect template -inline auto HashValue(const T& value, uint64_t seed) -> HashCode; - -// The same as the seeded version of `HashValue` but without callers needing to -// provide a seed. -// -// Generally prefer the seeded version, but this is available if there is no -// reasonable seed. In particular, this will behave better than using a seed of -// `0`. One important use case is for recursive hashing of sub-objects where -// appropriate or needed. -template inline auto HashValue(const T& value) -> HashCode; // Object and APIs that eventually produce a hash code. @@ -199,8 +185,8 @@ inline auto HashValue(const T& value) -> HashCode; // // Example usage: // ```cpp -// auto CarbonHashValue(const MyType& value, uint64_t seed) -> HashCode { -// Hasher hasher(seed); +// auto CarbonHashValue(const MyType& value) -> HashCode { +// Hasher hasher; // hasher.HashTwo(value.x, value.y); // return static_cast(hasher); // } @@ -221,7 +207,6 @@ inline auto HashValue(const T& value) -> HashCode; class Hasher { public: Hasher() = default; - explicit Hasher(uint64_t seed) : buffer(seed) {} Hasher(Hasher&& arg) = default; Hasher(const Hasher& arg) = delete; @@ -311,6 +296,13 @@ class Hasher { static auto Read4(const std::byte* data) -> uint64_t; static auto Read8(const std::byte* data) -> uint64_t; + // Returns `value` XOR-ed with `imm` sign-extended to 64 bits, keeping `imm` + // an immediate operand of the XOR on x86-64. When `value` comes directly from + // a read, instruction selection otherwise folds the read into the XOR and + // materializes `imm` in a register, which a loop then hoists and keeps live. + // Hiding `value` from the optimizer prevents that. + static auto XorImmediate(uint64_t value, int32_t imm) -> uint64_t; + // Similar to the `ReadN` functions, but supports reading a range of different // bytes provided by the size *without branching on the size*. The lack of // branches is often key, and the code in these routines works to be efficient @@ -355,7 +347,9 @@ class Hasher { // multiplication. However, it is not *necessary* as we do capture the // complete 128-bit result. Where reasonable, the caller should XOR random // data into operands before calling `Mix` to try and increase the - // distribution of bits feeding the multiply. + // distribution of bits feeding the multiply. The operands of each `Mix` use + // `ImmediateRandomData` for this, and use `StaticRandomData` only to encode + // a size. static auto Mix(uint64_t lhs, uint64_t rhs) -> uint64_t; // An alternative to `Mix` that is significantly weaker but also lower @@ -392,10 +386,10 @@ class Hasher { // Random data taken from the hexadecimal digits of Pi's fractional component, // written in lexical order for convenience of reading. The resulting - // byte-stream will be different due to little-endian integers. These can be - // used directly for convenience rather than calling `SampleRandomData`, but - // be aware that this is the underlying pool. The goal is to reuse the same - // single cache-line of constant data. + // byte-stream will be different due to little-endian integers. This pool is + // sampled with `SampleRandomData` to encode sizes into the hash, and is used + // directly by the large-input routine. The goal is to reuse the same single + // cache-line of constant data. // // The initializers here can be generated with the following shell script, // which will generate 8 64-bit values and one more digit. The `bc` command's @@ -417,6 +411,33 @@ class Hasher { 0xc0ac'29b7'c97c'50dd, 0x3f84'd5b5'b547'0917, }; + // Random data XOR-ed into the operands of `Mix` so that common inputs, such + // as all-zero bytes, don't zero an operand, and to spread bits across the + // multiply. These are 32-bit values, sign-extended on use: 32 bits of + // random data is enough for this, and x86-64 can XOR a sign-extended 32-bit + // value in as an immediate operand, where a full 64-bit constant costs an + // extra instruction to materialize. They are also independent of + // `StaticRandomData`, so they can't correlate with a sample of that pool on + // the other operand of the same `Mix`. + // + // The values are successive 32-bit chunks of the hexadecimal digits of e's + // fractional component. The initializers can be generated with the + // following shell script: + // + // ```sh + // echo 'obase=16; scale=40; e(1)' | bc -l \ + // | cut -c 3-34 | tr '[:upper:]' '[:lower:]' \ + // | sed -e "s/.\{4\}/&'/g" \ + // | sed -e "s/\(.\{4\}'.\{4\}\)'/0x\1,\n/g" + // ``` + static constexpr std::array ImmediateRandomData = + std::bit_cast>(std::array{ + 0xb7e1'5162, + 0x8aed'2a6a, + 0xbf71'5880, + 0x9cf4'f3c7, + }); + // We need a multiplicative hashing constant for both 64-bit multiplicative // hashing fast paths and some other 128-bit folded multiplies. We use an // empirically better constant compared to Knuth's, Rust's FxHash, and others @@ -448,7 +469,7 @@ class Hasher { static constexpr uint64_t MulConstant = 0x79d5'f9e0'de1e'8cf5U; private: - uint64_t buffer; + uint64_t buffer = 0; }; // A dedicated namespace for `CarbonHashValue` overloads that are not found by @@ -460,42 +481,37 @@ class Hasher { namespace InternalHashDispatch { template -inline auto CarbonHashValue(llvm::ArrayRef values, uint64_t seed) - -> HashCode { - Hasher hasher(seed); +inline auto CarbonHashValue(llvm::ArrayRef values) -> HashCode { + Hasher hasher; hasher.HashArray(values); return static_cast(hasher); } -inline auto CarbonHashValue(llvm::ArrayRef bytes, uint64_t seed) - -> HashCode { - Hasher hasher(seed); +inline auto CarbonHashValue(llvm::ArrayRef bytes) -> HashCode { + Hasher hasher; hasher.HashSizedBytes(bytes); return static_cast(hasher); } // Hashing implementation for `llvm::StringRef`. We forward all the other // string-like types that support heterogeneous lookup to this one. -inline auto CarbonHashValue(llvm::StringRef value, uint64_t seed) -> HashCode { - return CarbonHashValue( - llvm::ArrayRef(reinterpret_cast(value.data()), - value.size()), - seed); +inline auto CarbonHashValue(llvm::StringRef value) -> HashCode { + return CarbonHashValue(llvm::ArrayRef( + reinterpret_cast(value.data()), value.size())); } -inline auto CarbonHashValue(std::string_view value, uint64_t seed) -> HashCode { - return CarbonHashValue(llvm::StringRef(value.data(), value.size()), seed); +inline auto CarbonHashValue(std::string_view value) -> HashCode { + return CarbonHashValue(llvm::StringRef(value.data(), value.size())); } -inline auto CarbonHashValue(const std::string& value, uint64_t seed) - -> HashCode { - return CarbonHashValue(llvm::StringRef(value.data(), value.size()), seed); +inline auto CarbonHashValue(const std::string& value) -> HashCode { + return CarbonHashValue(llvm::StringRef(value.data(), value.size())); } template -inline auto CarbonHashValue(const llvm::SmallString& value, - uint64_t seed) -> HashCode { - return CarbonHashValue(llvm::StringRef(value.data(), value.size()), seed); +inline auto CarbonHashValue(const llvm::SmallString& value) + -> HashCode { + return CarbonHashValue(llvm::StringRef(value.data(), value.size())); } // Support types that are array-like by building an `llvm::ArrayRef` out of @@ -503,37 +519,32 @@ inline auto CarbonHashValue(const llvm::SmallString& value, // because that type supports building a synthetic array out of any single // element. template -inline auto CarbonHashValue(const std::vector& arg, uint64_t seed) - -> HashCode { - return CarbonHashValue(llvm::ArrayRef(arg), seed); +inline auto CarbonHashValue(const std::vector& arg) -> HashCode { + return CarbonHashValue(llvm::ArrayRef(arg)); } template -inline auto CarbonHashValue(const llvm::SmallVectorImpl& arg, uint64_t seed) - -> HashCode { - return CarbonHashValue(llvm::ArrayRef(arg), seed); +inline auto CarbonHashValue(const llvm::SmallVectorImpl& arg) -> HashCode { + return CarbonHashValue(llvm::ArrayRef(arg)); } template -inline auto CarbonHashValue(const std::array& arg, uint64_t seed) - -> HashCode { - return CarbonHashValue(llvm::ArrayRef(arg), seed); +inline auto CarbonHashValue(const std::array& arg) -> HashCode { + return CarbonHashValue(llvm::ArrayRef(arg)); } template -inline auto CarbonHashValue(const T (&arg)[N], uint64_t seed) -> HashCode { - return CarbonHashValue(llvm::ArrayRef(arg), seed); +inline auto CarbonHashValue(const T (&arg)[N]) -> HashCode { + return CarbonHashValue(llvm::ArrayRef(arg)); } template -inline auto CarbonHashValue(const std::tuple& value, uint64_t seed) - -> HashCode { - Hasher hasher(seed); +inline auto CarbonHashValue(const std::tuple& value) -> HashCode { + Hasher hasher; std::apply([&](const auto&... args) { hasher.Hash(args...); }, value); return static_cast(hasher); } template -inline auto CarbonHashValue(const std::pair& value, uint64_t seed) - -> HashCode { - Hasher hasher(seed); +inline auto CarbonHashValue(const std::pair& value) -> HashCode { + Hasher hasher; hasher.Hash(value.first, value.second); return static_cast(hasher); } @@ -550,8 +561,8 @@ concept HasCustomHashValue = requires { CustomHashValue::Hash; }; // overload available for a particular type, either in this namespace or found // via ADL. Note that this should not be moved above any overloads. template -concept HasCarbonHashValue = requires(const T& value, uint64_t seed) { - { CarbonHashValue(value, seed) } -> std::same_as; +concept HasCarbonHashValue = requires(const T& value) { + { CarbonHashValue(value) } -> std::same_as; }; // C++ guarantees this is true for the unsigned variants, but we require it for @@ -596,21 +607,21 @@ concept CanHashAsRawDataType = std::same_as || // overloads, either here, or via ADL. Note that similar to // `HasCarbonHashValue`, this must not be moved above any of those overloads. template -inline auto DispatchImpl(const T& value, uint64_t seed) -> HashCode { +inline auto DispatchImpl(const T& value) -> HashCode { if constexpr (HasCarbonHashValue) { // If we have an explicit overload for `CarbonHashValue`, call it. This may // be provided above or via ADL, and is preferred as it represents an // explicit request for how the type is hashed. - return CarbonHashValue(value, seed); + return CarbonHashValue(value); } else if constexpr (HasCustomHashValue) { // If we have an explicit specialization for `CustomHashValue`, call it. // This is a fallback explicit hashing path that doesn't require ADL or // being in this header. - return CustomHashValue::Hash(value, seed); + return CustomHashValue::Hash(value); } else if constexpr (CanHashAsRawDataType) { // There was no explicit overload or specialization to call, but the type // allows us to hash it as raw data, do so. - Hasher hasher(seed); + Hasher hasher; hasher.HashRaw(MapToRawDataType(value)); return static_cast(hasher); } else { @@ -626,18 +637,9 @@ inline auto DispatchImpl(const T& value, uint64_t seed) -> HashCode { } // namespace InternalHashDispatch -template -inline auto HashValue(const T& value, uint64_t seed) -> HashCode { - return InternalHashDispatch::DispatchImpl(value, seed); -} - template inline auto HashValue(const T& value) -> HashCode { - // When a seed isn't provided, use the last 64-bit chunk of random data. Other - // chunks (especially the first) are more often XOR-ed with the seed and risk - // cancelling each other out and feeding a zero to a `Mix` call in a way that - // sharply increasing collisions. - return HashValue(value, Hasher::StaticRandomData[7]); + return InternalHashDispatch::DispatchImpl(value); } constexpr auto HashCode::ExtractIndex() -> ssize_t { return value_; } @@ -689,6 +691,13 @@ inline auto Hasher::Read8(const std::byte* data) -> uint64_t { return result; } +inline auto Hasher::XorImmediate(uint64_t value, int32_t imm) -> uint64_t { +#if defined(__x86_64__) + __asm__("" : "+r"(value)); +#endif + return value ^ static_cast(static_cast(imm)); +} + inline auto Hasher::Read1To3(const std::byte* data, ssize_t size) -> uint64_t { // Use carefully crafted indexing to avoid branches on the exact size while // reading. @@ -745,23 +754,16 @@ inline auto Hasher::HashDense(uint64_t data) -> void { inline auto Hasher::HashDense(uint64_t data0, uint64_t data1) -> void { // When hashing two chunks of data at the same time, we XOR it with random // data to avoid common inputs from having especially bad multiplicative - // effects. We also XOR in the starting buffer as seed or to chain. Note that - // we don't use *consecutive* random data 64-bit values to avoid a common - // compiler "optimization" of loading both 64-bit chunks into a 128-bit vector - // and doing the XOR in the vector unit. The latency of extracting the data - // afterward eclipses any benefit. Callers will routinely have two consecutive - // data values here, but using non-consecutive keys avoids any vectorization - // being tempting. + // effects. We also XOR in the starting buffer to chain. // - // XOR-ing both the incoming state and a random word over the second data is - // done to pipeline with materializing the constants and is observed to have - // better performance than XOR-ing after the mix. + // XOR-ing both the incoming state and random data over the second data is + // observed to have better performance than XOR-ing after the mix. // // This roughly matches the mix pattern used in the larger mixing routines // from Abseil, which is a more minimal form than used in other algorithms // such as AHash and seems adequate for latency-optimized use cases. - buffer = - Mix(data0 ^ StaticRandomData[1], data1 ^ StaticRandomData[3] ^ buffer); + buffer = Mix(XorImmediate(data0, ImmediateRandomData[3]), + XorImmediate(data1, ImmediateRandomData[2]) ^ buffer); } template @@ -818,7 +820,7 @@ inline auto Hasher::Hash(const Ts&... values) -> void { auto map_value = [](const T& value) -> uint64_t { if constexpr (HasCarbonHashValue || HasCustomHashValue) { // Use the top-level `HashValue` to re-dispatch to the custom - // implementation with a fixed seed. + // implementation. return static_cast(HashValue(value)); } else if constexpr (CanHashAsRawDataType) { auto raw_value = MapToRawDataType(value); @@ -828,8 +830,7 @@ inline auto Hasher::Hash(const Ts&... values) -> void { if constexpr (sizeof(raw_value) <= 8) { return ReadSmall(raw_value); } else { - // Use the top-level `HashValue` to pick up a good fixed seed and hash - // this large object as raw data. + // Use the top-level `HashValue` to hash this large object as raw data. return static_cast(HashValue(raw_value)); } } else { @@ -912,13 +913,14 @@ inline auto Hasher::HashRaw(const T& value) -> void { if constexpr (16 < sizeof(T) && sizeof(T) <= 32) { CARBON_MCA_BEGIN("fixed-32b"); // Essentially the same technique used for dynamically sized byte sequences - // of this size, but we start with a fixed XOR of random data. - buffer ^= StaticRandomData[0]; - uint64_t m0 = Mix(Read8(data_ptr) ^ StaticRandomData[1], - Read8(data_ptr + 8) ^ buffer); + // of this size, but with a fixed XOR of random data in place of the size. + uint64_t m0 = + Mix(XorImmediate(Read8(data_ptr), ImmediateRandomData[3]), + XorImmediate(Read8(data_ptr + 8), ImmediateRandomData[1]) ^ buffer); const std::byte* tail_16b_ptr = data_ptr + (sizeof(T) - 16); - uint64_t m1 = Mix(Read8(tail_16b_ptr) ^ StaticRandomData[3], - Read8(tail_16b_ptr + 8) ^ buffer); + uint64_t m1 = Mix( + XorImmediate(Read8(tail_16b_ptr), ImmediateRandomData[2]), + XorImmediate(Read8(tail_16b_ptr + 8), ImmediateRandomData[1]) ^ buffer); buffer = m0 ^ m1; CARBON_MCA_END("fixed-32b"); return; @@ -948,7 +950,11 @@ inline auto Hasher::HashSizedBytes(llvm::ArrayRef bytes) -> void { // Note that we don't drop to the `WeakMix` routine here because we want // to use sampled random data to encode the size, which may not be as // effective without the full 128-bit folded result. - buffer = Mix(data ^ buffer, SampleAlignedRandomData(size - 1)); + // + // The data is XOR-ed with random data so that all-zero data doesn't zero + // the multiply and lose the size. + buffer = Mix(XorImmediate(data, ImmediateRandomData[0]) ^ buffer, + SampleAlignedRandomData(size - 1)); CARBON_MCA_END("dynamic-8b"); return; } @@ -972,12 +978,13 @@ inline auto Hasher::HashSizedBytes(llvm::ArrayRef bytes) -> void { if (size <= 16) { CARBON_MCA_BEGIN("dynamic-16b"); // Similar to the above, we optimize primarily for latency here and spread - // the incoming data across both ends of the multiply. Note that this does - // have a drawback -- any time one half of the mix function becomes zero it - // will fail to incorporate any bits from the other half. However, there is - // exactly 1 in 2^64 values for each side that achieve this, and only when - // the size is exactly 16 -- for smaller sizes there is an overlapping byte - // that makes this impossible unless the seed is *also* incredibly unlucky. + // the incoming data across both ends of the multiply. Any time one half of + // the mix function becomes zero it fails to incorporate any bits from the + // other half, so both halves are XOR-ed with random data: a sample of the + // pool encoding the size, and a 32-bit constant. Otherwise the common case + // of trailing zero bytes, such as `{x, 0, 0}` as an array of `int32_t`, + // would zero the second half and hash every `x` the same. With the random + // data, exactly 1 in 2^64 values for each half is a problem. // // Because this hash function makes no attempt to defend against hash // flooding, we accept this risk in order to keep the latency low. If this @@ -985,7 +992,8 @@ inline auto Hasher::HashSizedBytes(llvm::ArrayRef bytes) -> void { // the 16-byte case down the next tier of cost. uint64_t size_hash = SampleRandomData(size); auto data = Read8To16(data_ptr, size); - buffer = Mix(data.first ^ size_hash, data.second ^ buffer); + buffer = Mix(data.first ^ size_hash, + XorImmediate(data.second, ImmediateRandomData[1]) ^ buffer); CARBON_MCA_END("dynamic-16b"); return; } @@ -994,13 +1002,23 @@ inline auto Hasher::HashSizedBytes(llvm::ArrayRef bytes) -> void { CARBON_MCA_BEGIN("dynamic-32b"); // Do two mixes of overlapping 16-byte ranges in parallel to minimize // latency. We also incorporate the size by sampling random data into the - // seed before both. + // buffer before both. + // + // The first operands use 32-bit constants rather than chunks of the pool. + // The sample reads bytes 17 through 39 of the pool, and a chunk that + // overlaps it is the same random data shifted by some bytes. Multiplying + // one by the other produces structured collisions. + // + // Both also go through `XorImmediate`, which keeps the two products at the + // same depth. Otherwise reassociation XORs the halves of `m0` together + // first, and on x86-64 the high half of a multiply arrives a cycle after + // the low half, lengthening the critical path by a cycle. buffer ^= SampleRandomData(size); - uint64_t m0 = Mix(Read8(data_ptr) ^ StaticRandomData[1], + uint64_t m0 = Mix(XorImmediate(Read8(data_ptr), ImmediateRandomData[3]), Read8(data_ptr + 8) ^ buffer); const std::byte* tail_16b_ptr = data_ptr + (size - 16); - uint64_t m1 = Mix(Read8(tail_16b_ptr) ^ StaticRandomData[3], + uint64_t m1 = Mix(XorImmediate(Read8(tail_16b_ptr), ImmediateRandomData[2]), Read8(tail_16b_ptr + 8) ^ buffer); // Just an XOR mix at the end is quite weak here, but we prefer that for // latency over a more robust approach. Doing another mix with the size (the diff --git a/common/hashing_benchmark.cpp b/common/hashing_benchmark.cpp index 479bcfa7ff13..0b506e83f75c 100644 --- a/common/hashing_benchmark.cpp +++ b/common/hashing_benchmark.cpp @@ -158,9 +158,9 @@ struct HashBenchBase { uint64_t seed; HashBenchBase() { - // The real-world use case we care about is in a hash table where we'll mix - // in some seed state, likely some ASLR address. To simulate this for - // benchmarking, compute a seed from the address of a stack local variable. + // The Abseil and LLVM hash tables mix in some seed state, likely some ASLR + // address. To simulate this for benchmarking, compute a seed from the + // address of a stack local variable. volatile char key; key = 42; // Rinse this through a volatile variable as well so returning it isn't @@ -171,10 +171,10 @@ struct HashBenchBase { } }; -struct CarbonHashBench : HashBenchBase { +struct CarbonHashBench { template auto operator()(const T& value) -> uint64_t { - return static_cast(HashValue(value, seed)); + return static_cast(HashValue(value)); } }; diff --git a/common/hashing_llvm.h b/common/hashing_llvm.h index b924d1d84f31..c753fb8c7e24 100644 --- a/common/hashing_llvm.h +++ b/common/hashing_llvm.h @@ -14,8 +14,8 @@ namespace Carbon::InternalHashDispatch { template <> struct CustomHashValue { - static auto Hash(llvm::APInt value, uint64_t seed) -> HashCode { - Hasher hasher(seed); + static auto Hash(llvm::APInt value) -> HashCode { + Hasher hasher; if (LLVM_LIKELY(value.isSingleWord())) { hasher.Hash(value.getBitWidth(), value.getZExtValue()); } else { @@ -29,12 +29,12 @@ struct CustomHashValue { template <> struct CustomHashValue { - static auto Hash(llvm::APFloat value, uint64_t seed) -> HashCode { - Hasher hasher(seed); + static auto Hash(llvm::APFloat value) -> HashCode { + Hasher hasher; // Hashing floating point numbers is complex and depends on the specific // internal semantics of `APFloat`, so delegate to the LLVM hashing - // framework here. We re-hash the result to mix in our seed. All of this is - // a bit inefficient, and we can revisit this to provide a dedicated + // framework here. We re-hash the result to mix it into our hash. All of + // this is a bit inefficient, and we can revisit this to provide a dedicated // implementation if it becomes a bottleneck. using llvm::hash_value; hasher.HashRaw(hash_value(value)); diff --git a/common/hashing_test.cpp b/common/hashing_test.cpp index cee95b29140d..cfc052f1f751 100644 --- a/common/hashing_test.cpp +++ b/common/hashing_test.cpp @@ -98,15 +98,6 @@ TEST(HashingTest, Integers) { } } -TEST(HashingTest, BasicSeeding) { - auto unseeded_hash = HashValue(42); - EXPECT_THAT(unseeded_hash, Ne(HashValue(42, 1))); - EXPECT_THAT(unseeded_hash, Ne(HashValue(42, 2))); - EXPECT_THAT(unseeded_hash, Ne(HashValue(42, 3))); - EXPECT_THAT(unseeded_hash, - Ne(HashValue(42, static_cast(unseeded_hash)))); -} - TEST(HashingTest, Pointers) { int object1 = 42; std::string object2 = @@ -366,8 +357,8 @@ struct HashableType { // help ensure that the hashing framework doesn't accidentally override this. template requires(std::same_as) - friend auto CarbonHashValue(const T& value, uint64_t seed) -> HashCode { - Hasher hasher(seed); + friend auto CarbonHashValue(const T& value) -> HashCode { + Hasher hasher; hasher.Hash(value.x, value.y); return static_cast(hasher); } @@ -468,11 +459,6 @@ TEST(HashingTest, TupleRecursion) { Eq(HashValue(std::tuple{a, c, a}))); } -// The only significantly bad seed is zero, so pick a non-zero seed with a tiny -// amount of entropy to make sure that none of the testing relies on the entropy -// from this. -constexpr uint64_t TestSeed = 42ULL * 1024; - auto ToHexBytes(llvm::StringRef s) -> std::string { RawStringOstream rendered; rendered << "{"; @@ -637,7 +623,7 @@ auto AllByteStringsHashedAndSorted() { bytes[j] = (static_cast(i) >> (8 * j)) & 0xff; } std::string s(std::begin(bytes), std::end(bytes)); - hashes.push_back({HashValue(s, TestSeed), s}); + hashes.push_back({HashValue(s), s}); } llvm::sort(hashes, [](const HashedString& lhs, const HashedString& rhs) { @@ -748,7 +734,7 @@ struct SparseHashTest : ::testing::Test { SetBitCount::Begin, std::min(bits, SetBitCount::End))) { if (set_bit_count == 0) { std::string s(byte_count, '\0'); - hashes.push_back({HashValue(s, TestSeed), std::move(s)}); + hashes.push_back({HashValue(s), std::move(s)}); continue; } for (int begin_set_bit : llvm::seq_inclusive(0, bits - set_bit_count)) { @@ -793,7 +779,7 @@ struct SparseHashTest : ::testing::Test { if (has_end_byte_bits) { s[end_set_bit_byte_index] &= end_set_bit_byte; } - hashes.push_back({HashValue(s, TestSeed), std::move(s)}); + hashes.push_back({HashValue(s), std::move(s)}); } } } diff --git a/common/hashtable_key_context.h b/common/hashtable_key_context.h index e5115a2629a1..a72b948c202a 100644 --- a/common/hashtable_key_context.h +++ b/common/hashtable_key_context.h @@ -79,10 +79,10 @@ auto HashtableEq(const LeftT& lhs, const RightT& rhs) -> bool; // llvm::ArrayRef interned_strings) // : interned_strings_(interned_strings) {} // -// auto HashKey(llvm::StringRef s, uint64_t seed) const -> HashCode { +// auto HashKey(llvm::StringRef s) const -> HashCode { // return HashValue(s); // } -// auto HashKey(int index_key, uint64_t seed) const -> HashCode { +// auto HashKey(int index_key) const -> HashCode { // return HashKey(interned_strings_[index_key]); // } // @@ -99,7 +99,7 @@ auto HashtableEq(const LeftT& lhs, const RightT& rhs) -> bool; // ``` struct DefaultKeyContext { template - auto HashKey(const AnyKeyT& key, uint64_t seed) const -> HashCode; + auto HashKey(const AnyKeyT& key) const -> HashCode; template auto KeyEq(const AnyKeyT& lhs_key, const TableKeyT& rhs_key) const -> bool; @@ -138,7 +138,7 @@ class TranslatingKeyContext { } template - auto HashKey(const AnyKeyT& key, uint64_t seed) const -> HashCode; + auto HashKey(const AnyKeyT& key) const -> HashCode; template auto KeyEq(const AnyKeyT& lhs_key, const TableKeyT& rhs_key) const -> bool; @@ -216,9 +216,8 @@ inline auto HashtableEq(const LeftT& lhs, const RightT& rhs) -> bool { } template -auto DefaultKeyContext::HashKey(const AnyKeyT& key, uint64_t seed) const - -> HashCode { - return HashValue(key, seed); +auto DefaultKeyContext::HashKey(const AnyKeyT& key) const -> HashCode { + return HashValue(key); } template @@ -229,13 +228,13 @@ auto DefaultKeyContext::KeyEq(const AnyKeyT& lhs_key, template template -auto TranslatingKeyContext::HashKey(const AnyKeyT& key, - uint64_t seed) const -> HashCode { +auto TranslatingKeyContext::HashKey(const AnyKeyT& key) const + -> HashCode { const DerivedT& self = *static_cast(this); if constexpr (requires { self.TranslateKey(key); }) { - return HashValue(self.TranslateKey(key), seed); + return HashValue(self.TranslateKey(key)); } else { - return HashValue(key, seed); + return HashValue(key); } } diff --git a/common/hashtable_key_context_test.cpp b/common/hashtable_key_context_test.cpp index d3d18285a1b4..92aef0a4ac32 100644 --- a/common/hashtable_key_context_test.cpp +++ b/common/hashtable_key_context_test.cpp @@ -121,9 +121,8 @@ TEST(HashtableKeyContextTest, HashtableEqAPFloat) { struct CustomHash { int x; - friend auto CarbonHashValue(const CustomHash& value, uint64_t seed) - -> HashCode { - return HashValue(value.x + 42, seed); + friend auto CarbonHashValue(const CustomHash& value) -> HashCode { + return HashValue(value.x + 42); } }; @@ -155,20 +154,15 @@ TEST(HashtableKeyContextTest, DefaultKeyContext) { EXPECT_FALSE(HashtableEq(zero_float, neg_zero_float)); // Also check hash dispatching. - uint64_t seed = 1234; - EXPECT_THAT(context.HashKey(42, seed), Eq(HashValue(42, seed))); - EXPECT_THAT(context.HashKey(CustomHash{.x = 1234}, seed), - Eq(HashValue(CustomHash{.x = 1234}, seed))); - EXPECT_THAT(context.HashKey(one_64, seed), Eq(HashValue(one_64, seed))); - EXPECT_THAT(context.HashKey(one_128, seed), Eq(HashValue(one_128, seed))); - EXPECT_THAT(context.HashKey(one_64, seed), - Ne(context.HashKey(one_128, seed))); - EXPECT_THAT(context.HashKey(zero_float, seed), - Eq(HashValue(zero_float, seed))); - EXPECT_THAT(context.HashKey(neg_zero_float, seed), - Eq(HashValue(neg_zero_float, seed))); - EXPECT_THAT(context.HashKey(zero_float, seed), - Ne(context.HashKey(neg_zero_float, seed))); + EXPECT_THAT(context.HashKey(42), Eq(HashValue(42))); + EXPECT_THAT(context.HashKey(CustomHash{.x = 1234}), + Eq(HashValue(CustomHash{.x = 1234}))); + EXPECT_THAT(context.HashKey(one_64), Eq(HashValue(one_64))); + EXPECT_THAT(context.HashKey(one_128), Eq(HashValue(one_128))); + EXPECT_THAT(context.HashKey(one_64), Ne(context.HashKey(one_128))); + EXPECT_THAT(context.HashKey(zero_float), Eq(HashValue(zero_float))); + EXPECT_THAT(context.HashKey(neg_zero_float), Eq(HashValue(neg_zero_float))); + EXPECT_THAT(context.HashKey(zero_float), Ne(context.HashKey(neg_zero_float))); } struct TestTranslatingKeyContext @@ -191,13 +185,12 @@ TEST(HashtableKeyContextTest, TranslatingKeyContext) { TestTranslatingKeyContext context = {.array = values}; - uint64_t seed = 1234; - EXPECT_THAT(context.HashKey(0, seed), Eq(HashValue(one_64, seed))); - EXPECT_THAT(context.HashKey(1, seed), Eq(HashValue(two_64, seed))); - EXPECT_THAT(context.HashKey(2, seed), Eq(HashValue(one_128, seed))); - EXPECT_THAT(context.HashKey(3, seed), Eq(HashValue(two_128, seed))); - EXPECT_THAT(context.HashKey(4, seed), Eq(HashValue(one_64, seed))); - EXPECT_THAT(context.HashKey(5, seed), Eq(HashValue(one_64, seed))); + EXPECT_THAT(context.HashKey(0), Eq(HashValue(one_64))); + EXPECT_THAT(context.HashKey(1), Eq(HashValue(two_64))); + EXPECT_THAT(context.HashKey(2), Eq(HashValue(one_128))); + EXPECT_THAT(context.HashKey(3), Eq(HashValue(two_128))); + EXPECT_THAT(context.HashKey(4), Eq(HashValue(one_64))); + EXPECT_THAT(context.HashKey(5), Eq(HashValue(one_64))); EXPECT_TRUE(context.KeyEq(one_64, 0)); EXPECT_TRUE(context.KeyEq(one_64, 4)); diff --git a/common/raw_hashtable.cpp b/common/raw_hashtable.cpp index 5a49dbb03610..b628230a448e 100644 --- a/common/raw_hashtable.cpp +++ b/common/raw_hashtable.cpp @@ -8,9 +8,12 @@ namespace Carbon::RawHashtable { +#ifndef NDEBUG +// A global variable whose address seeds the iteration entropy pool. This allows +// ASLR to introduce some variation in debug iteration order when enabled via +// the code model for globals. volatile std::byte global_addr_seed{1}; -#ifndef NDEBUG std::atomic entropy_hash = Carbon::HashValue(reinterpret_cast(&global_addr_seed)); #endif diff --git a/common/raw_hashtable.h b/common/raw_hashtable.h index 7650621bdba3..e0ae0ff38941 100644 --- a/common/raw_hashtable.h +++ b/common/raw_hashtable.h @@ -78,6 +78,10 @@ // - The storage for an entry is an internal type that should not be exposed to // users, and instead only the underlying keys and values. // +// - Keys are hashed with the unseeded `HashValue`; there is no per-table seed. +// This makes a table's layout, and any collisions in it, reproducible +// between runs. Debug builds vary the iteration order in `entries()` instead. +// // - The hash addressing and probing occurs over *groups* of slots rather than // individual entries. When inserting a new entry, it can be added to the // group it hashes to as long it is not full, and can even replace a slot with @@ -868,19 +872,6 @@ class TableImpl : public InputBaseT { // //////////////////////////////////////////////////////////////////////////////// -// Computes a seed that provides a small amount of entropy from ASLR where -// available with minimal cost. The priority is speed, and this computes the -// entropy in a way that doesn't require loading from memory, merely accessing -// entropy already available without accessing memory. -inline auto ComputeSeed() -> uint64_t { - // A global variable whose address is used as a seed. This allows ASLR to - // introduce some variation in hashtable ordering when enabled via the code - // model for globals. - extern volatile std::byte global_addr_seed; - - return reinterpret_cast(&global_addr_seed); -} - #ifndef NDEBUG // A pool of entropy used to vary the iteration order of hashtables in debug // builds. It is seeded from ASLR where available. @@ -980,7 +971,7 @@ auto ViewImpl::LookupEntry( CARBON_DCHECK(local_size > 0); uint8_t* local_metadata = metadata(); - HashCode hash = key_context.HashKey(lookup_key, ComputeSeed()); + HashCode hash = key_context.HashKey(lookup_key); auto [hash_index, tag] = hash.ExtractIndexAndTag<7>(); EntryT* local_entries = entries_data(); @@ -1057,8 +1048,7 @@ auto ViewImpl::ComputeMetricsImpl( for (ssize_t byte_index : present_matched_range) { ++metrics.key_count; ssize_t index = group_index + byte_index; - HashCode hash = - key_context.HashKey(local_entries[index].key(), ComputeSeed()); + HashCode hash = key_context.HashKey(local_entries[index].key()); auto [hash_index, tag] = hash.ExtractIndexAndTag<7>(); ProbeSequence s(hash_index, local_size); metrics.probed_key_count += @@ -1257,7 +1247,7 @@ auto BaseImpl::InsertImpl( uint8_t* local_metadata = metadata(); - HashCode hash = key_context.HashKey(lookup_key, ComputeSeed()); + HashCode hash = key_context.HashKey(lookup_key); auto [hash_index, tag] = hash.ExtractIndexAndTag<7>(); // We re-purpose the empty control byte to signal no insert is needed to the @@ -1383,8 +1373,7 @@ BaseImpl::GrowToAllocSizeImpl( for (ssize_t byte_index : present_matched_range) { ++count; ssize_t index = group_index + byte_index; - HashCode hash = - key_context.HashKey(old_entries[index].key(), ComputeSeed()); + HashCode hash = key_context.HashKey(old_entries[index].key()); EntryT* new_entry = InsertIntoEmpty(hash); new_entry->MoveFrom(std::move(old_entries[index])); } @@ -1799,8 +1788,7 @@ auto BaseImpl::GrowToNextAllocSize( CARBON_DCHECK(new_metadata[old_index | old_size] == old_metadata[old_index]); } - HashCode hash = - key_context.HashKey(old_entries[old_index].key(), ComputeSeed()); + HashCode hash = key_context.HashKey(old_entries[old_index].key()); ssize_t old_hash_index = hash.ExtractIndexAndTag<7>().first & ComputeProbeMaskFromSize(old_size); if (LLVM_UNLIKELY(old_hash_index != group_index)) { diff --git a/common/raw_hashtable_benchmark_helpers.cpp b/common/raw_hashtable_benchmark_helpers.cpp index e53355dddcea..9927d8a9713c 100644 --- a/common/raw_hashtable_benchmark_helpers.cpp +++ b/common/raw_hashtable_benchmark_helpers.cpp @@ -372,9 +372,8 @@ auto DumpHashStatistics(llvm::ArrayRef keys) -> void { constexpr int GroupShift = llvm::ConstantLog2(); size_t mask = ComputeProbeMaskFromSize(expected_size); - uint64_t salt = ComputeSeed(); - auto get_hash_index = [mask, salt](auto x) -> ssize_t { - auto [hash_index, _] = HashValue(x, salt).template ExtractIndexAndTag<7>(); + auto get_hash_index = [mask](auto x) -> ssize_t { + auto [hash_index, _] = HashValue(x).template ExtractIndexAndTag<7>(); return (hash_index & mask) >> GroupShift; }; @@ -408,9 +407,8 @@ auto DumpHashStatistics(llvm::ArrayRef keys) -> void { for (auto i : llvm::ArrayRef(grouped_key_indices[max_group_index]) .take_front(2 * GroupSize)) { auto k = keys[i]; - auto hash = static_cast(HashValue(k, salt)); + auto hash = static_cast(HashValue(k)); llvm::errs() << " key: " << k - << " salt: " << llvm::formatv("{0:x16}", salt) << " hash: " << llvm::formatv("{0:x16}", hash) << "\n"; } } diff --git a/common/raw_hashtable_benchmark_helpers.h b/common/raw_hashtable_benchmark_helpers.h index 04e68c89d84b..5825c410df93 100644 --- a/common/raw_hashtable_benchmark_helpers.h +++ b/common/raw_hashtable_benchmark_helpers.h @@ -79,9 +79,8 @@ struct LowZeroBitInt { constexpr auto operator<=>(const LowZeroBitInt& rhs) const -> std::strong_ordering = default; - friend auto CarbonHashValue(const LowZeroBitInt& value, uint64_t seed) - -> HashCode { - return HashValue(value.shifted_value, seed); + friend auto CarbonHashValue(const LowZeroBitInt& value) -> HashCode { + return HashValue(value.shifted_value); } template diff --git a/common/raw_hashtable_test_helpers.h b/common/raw_hashtable_test_helpers.h index e4f42882a17c..24df6f7ba38e 100644 --- a/common/raw_hashtable_test_helpers.h +++ b/common/raw_hashtable_test_helpers.h @@ -38,8 +38,8 @@ struct TestData : Printable { return lhs.value <=> rhs.value; } - friend auto CarbonHashValue(TestData data, uint64_t seed) -> HashCode { - return Carbon::HashValue(data.value, seed); + friend auto CarbonHashValue(TestData data) -> HashCode { + return Carbon::HashValue(data.value); } }; @@ -74,9 +74,8 @@ struct MoveOnlyTestData : Printable { const MoveOnlyTestData& rhs) -> std::strong_ordering = default; - friend auto CarbonHashValue(const MoveOnlyTestData& data, uint64_t seed) - -> HashCode { - return Carbon::HashValue(data.value, seed); + friend auto CarbonHashValue(const MoveOnlyTestData& data) -> HashCode { + return Carbon::HashValue(data.value); } }; @@ -92,8 +91,8 @@ inline auto CarbonHashtableEq(int lhs, const MoveOnlyTestData& rhs) -> bool { // fails to be used. struct TestKeyContext : DefaultKeyContext { template - auto HashKey(const KeyT& key, uint64_t seed) const -> HashCode { - Hasher hash(seed); + auto HashKey(const KeyT& key) const -> HashCode { + Hasher hash; // Inject some other data to the hash. hash.HashRaw(42); hash.HashRaw(HashValue(key)); @@ -108,8 +107,8 @@ struct TestKeyContext : DefaultKeyContext { template struct FixedHashKeyContext : DefaultKeyContext { template - auto HashKey(const KeyT& key, uint64_t seed) const -> HashCode { - HashCode original_hash = HashValue(key, seed); + auto HashKey(const KeyT& key) const -> HashCode { + HashCode original_hash = HashValue(key); auto raw_hash = static_cast(original_hash); constexpr uint64_t TagMask = (1U << TagBits) - 1; diff --git a/toolchain/lex/mismatched_brackets.cpp b/toolchain/lex/mismatched_brackets.cpp index a81524188f65..f9f0aa1a6fda 100644 --- a/toolchain/lex/mismatched_brackets.cpp +++ b/toolchain/lex/mismatched_brackets.cpp @@ -685,8 +685,8 @@ struct StateKey { friend auto operator==(const StateKey& lhs, const StateKey& rhs) -> bool = default; - friend auto CarbonHashValue(const StateKey& key, uint64_t seed) -> HashCode { - Hasher hasher(seed); + friend auto CarbonHashValue(const StateKey& key) -> HashCode { + Hasher hasher; hasher.Hash(key.stack, key.closer_inserted); return static_cast(hasher); } diff --git a/toolchain/sem_ir/clang_decl.h b/toolchain/sem_ir/clang_decl.h index 87d7f7cb818a..e91fb0c704f9 100644 --- a/toolchain/sem_ir/clang_decl.h +++ b/toolchain/sem_ir/clang_decl.h @@ -93,16 +93,12 @@ struct ClangDeclSignature : public Printable { auto operator==(const ClangDeclSignature& rhs) const -> bool = default; // Hashing for ClangDeclSignature. - friend auto CarbonHashValue(const ClangDeclSignature& value, uint64_t seed) - -> HashCode { - HashCode code = - HashValue(std::tuple{value.kind, value.num_params, - static_cast(value.self_passing_mode)}, - seed); - for (auto mode : value.passing_modes) { - code = HashValue(static_cast(mode), static_cast(code)); - } - return code; + friend auto CarbonHashValue(const ClangDeclSignature& value) -> HashCode { + Hasher hasher; + hasher.Hash(value.kind, value.num_params, + static_cast(value.self_passing_mode), + llvm::ArrayRef(value.passing_modes)); + return static_cast(hasher); } }; @@ -139,9 +135,8 @@ struct ClangDeclKey : public Printable { auto operator==(const ClangDeclKey& rhs) const -> bool = default; // Hashing for ClangDecl. See common/hashing.h. - friend auto CarbonHashValue(const ClangDeclKey& value, uint64_t seed) - -> HashCode { - return HashValue(std::tuple{value.decl, value.signature_id}, seed); + friend auto CarbonHashValue(const ClangDeclKey& value) -> HashCode { + return HashValue(std::tuple{value.decl, value.signature_id}); } // The Clang declaration pointing to the Clang AST. diff --git a/toolchain/sem_ir/declared_facet_type.h b/toolchain/sem_ir/declared_facet_type.h index d3ff5467c856..eba5b61598cf 100644 --- a/toolchain/sem_ir/declared_facet_type.h +++ b/toolchain/sem_ir/declared_facet_type.h @@ -137,9 +137,8 @@ using DeclaredFacetTypeStore = CanonicalValueStore>; // See common/hashing.h. -inline auto CarbonHashValue(const DeclaredFacetType& value, uint64_t seed) - -> HashCode { - Hasher hasher(seed); +inline auto CarbonHashValue(const DeclaredFacetType& value) -> HashCode { + Hasher hasher; hasher.HashArray(llvm::ArrayRef(value.extend_constraints)); hasher.HashArray(llvm::ArrayRef(value.self_impls_constraints)); hasher.HashArray(llvm::ArrayRef(value.extend_named_constraints)); diff --git a/toolchain/sem_ir/entity_name.h b/toolchain/sem_ir/entity_name.h index 107e22daf0b5..2087d924b8a0 100644 --- a/toolchain/sem_ir/entity_name.h +++ b/toolchain/sem_ir/entity_name.h @@ -44,9 +44,8 @@ struct EntityName : public Printable { } // Hashing for EntityName. See common/hashing.h. - friend auto CarbonHashValue(const EntityName& value, uint64_t seed) - -> HashCode { - Hasher hasher(seed); + friend auto CarbonHashValue(const EntityName& value) -> HashCode { + Hasher hasher; hasher.HashRaw(value.IdentityKey()); return static_cast(hasher); } diff --git a/toolchain/sem_ir/inst.h b/toolchain/sem_ir/inst.h index 8166c59e5dd5..3925268265e3 100644 --- a/toolchain/sem_ir/inst.h +++ b/toolchain/sem_ir/inst.h @@ -705,8 +705,8 @@ class InstBlockStore }; // See common/hashing.h. -inline auto CarbonHashValue(const Inst& value, uint64_t seed) -> HashCode { - Hasher hasher(seed); +inline auto CarbonHashValue(const Inst& value) -> HashCode { + Hasher hasher; hasher.HashRaw(value); return static_cast(hasher); } diff --git a/toolchain/sem_ir/struct_type_field.h b/toolchain/sem_ir/struct_type_field.h index aa44797a8882..5b561ea2c593 100644 --- a/toolchain/sem_ir/struct_type_field.h +++ b/toolchain/sem_ir/struct_type_field.h @@ -28,9 +28,8 @@ using StructTypeFieldsStore = BlockValueStore>; // See common/hashing.h. Supports canonicalization of fields. -inline auto CarbonHashValue(const StructTypeField& value, uint64_t seed) - -> HashCode { - Hasher hasher(seed); +inline auto CarbonHashValue(const StructTypeField& value) -> HashCode { + Hasher hasher; hasher.HashRaw(value); return static_cast(hasher); }