Skip to content

Commit 5e5c07a

Browse files
kyulee-comkyulee-com
committed
[StableHash][NFC] Implement with xxh3_64bits
1 parent e439fdf commit 5e5c07a

File tree

3 files changed

+22
-78
lines changed

3 files changed

+22
-78
lines changed

‎llvm/include/llvm/ADT/StableHashing.h

Lines changed: 11 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -16,85 +16,37 @@
1616
#define LLVM_ADT_STABLEHASHING_H
1717

1818
#include "llvm/ADT/StringRef.h"
19+
#include "llvm/Support/xxhash.h"
1920

2021
namespace llvm {
2122

2223
/// An opaque object representing a stable hash code. It can be serialized,
2324
/// deserialized, and is stable across processes and executions.
2425
using stable_hash = uint64_t;
2526

26-
// Implementation details
27-
namespace hashing {
28-
namespace detail {
29-
30-
// Stable hashes are based on the 64-bit FNV-1 hash:
31-
// https://en.wikipedia.org/wiki/Fowler-Noll-Vo_hash_function
32-
33-
const uint64_t FNV_PRIME_64 = 1099511628211u;
34-
const uint64_t FNV_OFFSET_64 = 14695981039346656037u;
35-
36-
inline void stable_hash_append(stable_hash &Hash, const char Value) {
37-
Hash = Hash ^ (Value & 0xFF);
38-
Hash = Hash * FNV_PRIME_64;
39-
}
40-
41-
inline void stable_hash_append(stable_hash &Hash, stable_hash Value) {
42-
for (unsigned I = 0; I < 8; ++I) {
43-
stable_hash_append(Hash, static_cast<char>(Value));
44-
Value >>= 8;
45-
}
27+
inline stable_hash stable_hash_combine(ArrayRef<stable_hash> Buffer) {
28+
const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(Buffer.data());
29+
size_t Size = Buffer.size() * sizeof(stable_hash);
30+
return xxh3_64bits(ArrayRef<uint8_t>(Ptr, Size));
4631
}
4732

48-
} // namespace detail
49-
} // namespace hashing
50-
5133
inline stable_hash stable_hash_combine(stable_hash A, stable_hash B) {
52-
stable_hash Hash = hashing::detail::FNV_OFFSET_64;
53-
hashing::detail::stable_hash_append(Hash, A);
54-
hashing::detail::stable_hash_append(Hash, B);
55-
return Hash;
34+
stable_hash Hashes[2] = {A, B};
35+
return stable_hash_combine(Hashes);
5636
}
5737

5838
inline stable_hash stable_hash_combine(stable_hash A, stable_hash B,
5939
stable_hash C) {
60-
stable_hash Hash = hashing::detail::FNV_OFFSET_64;
61-
hashing::detail::stable_hash_append(Hash, A);
62-
hashing::detail::stable_hash_append(Hash, B);
63-
hashing::detail::stable_hash_append(Hash, C);
64-
return Hash;
40+
stable_hash Hashes[3] = {A, B, C};
41+
return stable_hash_combine(Hashes);
6542
}
6643

6744
inline stable_hash stable_hash_combine(stable_hash A, stable_hash B,
6845
stable_hash C, stable_hash D) {
69-
stable_hash Hash = hashing::detail::FNV_OFFSET_64;
70-
hashing::detail::stable_hash_append(Hash, A);
71-
hashing::detail::stable_hash_append(Hash, B);
72-
hashing::detail::stable_hash_append(Hash, C);
73-
hashing::detail::stable_hash_append(Hash, D);
74-
return Hash;
75-
}
76-
77-
/// Compute a stable_hash for a sequence of values.
78-
///
79-
/// This hashes a sequence of values. It produces the same stable_hash as
80-
/// 'stable_hash_combine(a, b, c, ...)', but can run over arbitrary sized
81-
/// sequences and is significantly faster given pointers and types which
82-
/// can be hashed as a sequence of bytes.
83-
template <typename InputIteratorT>
84-
stable_hash stable_hash_combine_range(InputIteratorT First,
85-
InputIteratorT Last) {
86-
stable_hash Hash = hashing::detail::FNV_OFFSET_64;
87-
for (auto I = First; I != Last; ++I)
88-
hashing::detail::stable_hash_append(Hash, *I);
89-
return Hash;
46+
stable_hash Hashes[4] = {A, B, C, D};
47+
return stable_hash_combine(Hashes);
9048
}
9149

92-
inline stable_hash stable_hash_combine_array(const stable_hash *P, size_t C) {
93-
stable_hash Hash = hashing::detail::FNV_OFFSET_64;
94-
for (size_t I = 0; I < C; ++I)
95-
hashing::detail::stable_hash_append(Hash, P[I]);
96-
return Hash;
97-
}
9850
} // namespace llvm
9951

10052
#endif

‎llvm/lib/CodeGen/MachineOperand.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -424,8 +424,7 @@ hash_code llvm::hash_value(const MachineOperand &MO) {
424424
const uint32_t *RegMask = MO.getRegMask();
425425
std::vector<stable_hash> RegMaskHashes(RegMask, RegMask + RegMaskSize);
426426
return hash_combine(MO.getType(), MO.getTargetFlags(),
427-
stable_hash_combine_array(RegMaskHashes.data(),
428-
RegMaskHashes.size()));
427+
stable_hash_combine(RegMaskHashes));
429428
}
430429

431430
assert(0 && "MachineOperand not associated with any MachineFunction");

‎llvm/lib/CodeGen/MachineStableHash.cpp

Lines changed: 10 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,7 @@ stable_hash llvm::stableHashValue(const MachineOperand &MO) {
6666
SmallVector<stable_hash> DefOpcodes;
6767
for (auto &Def : MRI.def_instructions(MO.getReg()))
6868
DefOpcodes.push_back(Def.getOpcode());
69-
return stable_hash_combine_range(DefOpcodes.begin(), DefOpcodes.end());
69+
return stable_hash_combine(DefOpcodes);
7070
}
7171

7272
// Register operands don't have target flags.
@@ -78,8 +78,8 @@ stable_hash llvm::stableHashValue(const MachineOperand &MO) {
7878
case MachineOperand::MO_FPImmediate: {
7979
auto Val = MO.isCImm() ? MO.getCImm()->getValue()
8080
: MO.getFPImm()->getValueAPF().bitcastToAPInt();
81-
auto ValHash =
82-
stable_hash_combine_array(Val.getRawData(), Val.getNumWords());
81+
auto ValHash = stable_hash_combine(
82+
ArrayRef<stable_hash>(Val.getRawData(), Val.getNumWords()));
8383
return stable_hash_combine(MO.getType(), MO.getTargetFlags(), ValHash);
8484
}
8585

@@ -126,10 +126,8 @@ stable_hash llvm::stableHashValue(const MachineOperand &MO) {
126126
const uint32_t *RegMask = MO.getRegMask();
127127
std::vector<llvm::stable_hash> RegMaskHashes(RegMask,
128128
RegMask + RegMaskSize);
129-
return stable_hash_combine(
130-
MO.getType(), MO.getTargetFlags(),
131-
stable_hash_combine_array(RegMaskHashes.data(),
132-
RegMaskHashes.size()));
129+
return stable_hash_combine(MO.getType(), MO.getTargetFlags(),
130+
stable_hash_combine(RegMaskHashes));
133131
}
134132
}
135133
}
@@ -145,10 +143,8 @@ stable_hash llvm::stableHashValue(const MachineOperand &MO) {
145143
MO.getShuffleMask(), std::back_inserter(ShuffleMaskHashes),
146144
[](int S) -> llvm::stable_hash { return llvm::stable_hash(S); });
147145

148-
return stable_hash_combine(
149-
MO.getType(), MO.getTargetFlags(),
150-
stable_hash_combine_array(ShuffleMaskHashes.data(),
151-
ShuffleMaskHashes.size()));
146+
return stable_hash_combine(MO.getType(), MO.getTargetFlags(),
147+
stable_hash_combine(ShuffleMaskHashes));
152148
}
153149
case MachineOperand::MO_MCSymbol: {
154150
auto SymbolName = MO.getMCSymbol()->getName();
@@ -212,24 +208,21 @@ stable_hash llvm::stableHashValue(const MachineInstr &MI, bool HashVRegs,
212208
HashComponents.push_back(static_cast<unsigned>(Op->getFailureOrdering()));
213209
}
214210

215-
return stable_hash_combine_range(HashComponents.begin(),
216-
HashComponents.end());
211+
return stable_hash_combine(HashComponents);
217212
}
218213

219214
stable_hash llvm::stableHashValue(const MachineBasicBlock &MBB) {
220215
SmallVector<stable_hash> HashComponents;
221216
// TODO: Hash more stuff like block alignment and branch probabilities.
222217
for (const auto &MI : MBB)
223218
HashComponents.push_back(stableHashValue(MI));
224-
return stable_hash_combine_range(HashComponents.begin(),
225-
HashComponents.end());
219+
return stable_hash_combine(HashComponents);
226220
}
227221

228222
stable_hash llvm::stableHashValue(const MachineFunction &MF) {
229223
SmallVector<stable_hash> HashComponents;
230224
// TODO: Hash lots more stuff like function alignment and stack objects.
231225
for (const auto &MBB : MF)
232226
HashComponents.push_back(stableHashValue(MBB));
233-
return stable_hash_combine_range(HashComponents.begin(),
234-
HashComponents.end());
227+
return stable_hash_combine(HashComponents);
235228
}

0 commit comments

Comments
 (0)