From 092470fdbfd7d062b0cd65ef540f01198cbfa4bd Mon Sep 17 00:00:00 2001 From: Alisa Sireneva Date: Wed, 11 Dec 2024 22:51:15 +0300 Subject: [PATCH] Thoughts on Rust hashing --- blog/thoughts-on-rust-hashing/index.html | 267 ++++++++++++ blog/thoughts-on-rust-hashing/index.md | 531 +++++++++++++++++++++++ blog/thoughts-on-rust-hashing/og.png | Bin 0 -> 113108 bytes 3 files changed, 798 insertions(+) create mode 100644 blog/thoughts-on-rust-hashing/index.html create mode 100644 blog/thoughts-on-rust-hashing/index.md create mode 100644 blog/thoughts-on-rust-hashing/og.png diff --git a/blog/thoughts-on-rust-hashing/index.html b/blog/thoughts-on-rust-hashing/index.html new file mode 100644 index 0000000..c028f87 --- /dev/null +++ b/blog/thoughts-on-rust-hashing/index.html @@ -0,0 +1,267 @@ +Thoughts on Rust hashing | purplesyringa's blog
GitHub

purplesyringa

Thoughts on Rust hashing

IntroIn languages like Python, Java, or C++, values are hashed by calling a “hash me” method on them, implemented by the type author. This fixed-hash size is then immediately used by the hash table or what have you. This design suffers from some obvious problems, like:

How do you hash an integer? If you use a no-op hasher (booo), DoS attacks on hash tables are inevitable. If you hash it thoroughly, consumers that only cache hashes to optimize equality checks lose out of performance.

How do you mix hashes? You can:

  • Leave that to the users. Everyone will then invent their own terrible mixers, like x ^ y. Indeed, both arguments are pseudo-random, what could possibly go wrong?
  • Provide a good-enough mixer for most use cases, like a * x + y. Cue CVEs because people used mix(x, mix(y, z)) instead of mix(mix(x, y), z).
  • Provide a quality mixer, missing out on performance in common simple cases.

What if the input data is already random? Then you’re just wasting cycles.

What guarantees do you provide regarding the hash values?

  • Do you require the avalanche effect? Your hash is suboptimal even for simple power-of-two-sized hash tables.
  • Do you require a half-avalanche effect instead? Congrats, you broke either those or prime-sized hash tables.
  • Do you require the hash table to perform finalization manually? Using strings as keys is now suboptimal, because computing a non-finalized hash of a string is of good enough quality already.

Is your hash function seeded?

  • If not, hi DoS.
  • If yes, but you reuse the same seed between different hash tables, your tables are now quadratic.
  • If the seed is explicitly passed to each hasher, how do you ensure different hashers don’t accidentally cancel out?

In RustRust learnt from these mistakes by splitting the responsibilities:

  • Objects implement the Hash trait, allowing them to write underlying data into a Hasher.
  • Hashers implement the Hasher trait, which hashes the data written by Hash objects.

Objects turn the structured data into a stream of integers; hashers turn the stream into a numeric hash.

On paper, this is a good solution:

  • Hashing an integer is as simple as sending the integer to the hasher. Consumers can choose hashers that provide the necessary guarantees.
  • Users don’t have to mix hashes. Hashers can do that optimally.
  • If the data is known to be random, a fast simple hasher can be used without changing the Hash implementation.
  • Different hash tables can use different hashers, efficiently providing only as much avalanche as necessary.
  • The hasher can be seeded per-table. Only the hasher has access to the seed, so safely using the seed during mixing is easy.

Surely this enables optimal and performant hashing in practice, right?

NoLet’s take a look at the Hasher API:

pub trait Hasher {
+    // Required methods
+    fn finish(&self) -> u64;
+    fn write(&mut self, bytes: &[u8]);
+
+    // Provided methods
+    fn write_u8(&mut self, i: u8) { ... }
+    fn write_u16(&mut self, i: u16) { ... }
+    fn write_u32(&mut self, i: u32) { ... }
+    fn write_u64(&mut self, i: u64) { ... }
+    fn write_u128(&mut self, i: u128) { ... }
+    fn write_usize(&mut self, i: usize) { ... }
+    fn write_i8(&mut self, i: i8) { ... }
+    fn write_i16(&mut self, i: i16) { ... }
+    fn write_i32(&mut self, i: i32) { ... }
+    fn write_i64(&mut self, i: i64) { ... }
+    fn write_i128(&mut self, i: i128) { ... }
+    fn write_isize(&mut self, i: isize) { ... }
+    fn write_length_prefix(&mut self, len: usize) { ... }
+    fn write_str(&mut self, s: &str) { ... }
+}
+

This API is tuned to streaming hashes, like the polynomial hash and its various knock-offs. But just like in encryption, hashing is block-wise these days.

Block hashes have some internal state that iteratively “absorbs” input blocks of a fixed length. When the data runs out, the last block is padded with length and absorbed as a fixed-length block too. A finalization step then reduces the internal state to 64 bits (or more, depending on the use case).

That’s how SHA-2 and many other cryptographic hashes work, but you might be surprised to know that the top hashes in the SMHasher list all use the same approach.

The block-wise design is objectively superior to streaming. Consuming as much data as possible at once reduces the amortized avalanche cost, enabling safer hash functions at greater speed than streaming hashes can achieve. Block-wise hashes have a lower latency, as the latency is accumulated per-block, not per-stream-input.

Block hash support in Rust

:ferrisClueless:The Hasher API makes no effort to suit block hashes. The hasher is not informed of the length of the data or of its structure. It must always be able to absorb just one more u8, bro, I promise. There’s only two ways to deal with this:

  • Either you pad all individual inputs, even very short ones, to the full block width,
  • Or you accumulate a block and occasionally flush it to the underlying block hasher.

Let’s see what’s wrong with these approaches.

PaddingLet’s consider a very simple block-wise hash:

fn absorb(state: &mut u64, block: &[u8; 8]) {
+    let block = u64::from_ne_bytes(*block);
+    *state = state.wrapping_mul(K).wrapping_add(block);
+}
+

This is just a multiplicative hash, not unlike FNV-1, but consuming 8 bytes at a time instead of 1.

Now what happens if you try to hash two 32-bit integers with this hash? With padding, that will compile to two multiplications even though one would work. This halves throughput and increases latency.

Practical hashes uses much larger blocks. rapidhash has a 24-byte state and can absorb 48 bytes at once. ahash has a 48-byte state and absorbs 64-byte blocks. meowhash has a 128-byte state and absorbs 256 bytes. (I only selected these particular hashes because I’m familiar with their kernels; others have similar designs.)

These are some of the fastest non-cryptographic hashes in the world. Do you really want to nuke their performance by padding 8-byte inputs to 48, 64, or 256 bytes? Probably not.

ChainsOkay, but what if we cheated and modified the hash functions to absorb small data somewhat more efficiently than absorbing a full block?

Say, the rapidhash kernel is effectively this:

fn absorb(state: &mut [u64; 3], seed: &[u64; 3], block: &[u64; 6]) {
+    for i in 0..3 {
+        state[i] = mix(block[i] ^ state[i], block[i + 3] ^ seed[i]);
+    }
+}
+

That’s three independent iterations, so surely we can absorb a smaller 64-bit block like this instead:

fn absorb_64bit(state: &mut [u64; 3], seed: &[u64; 3], block: u64) {
+    state[0] = mix(block ^ state[0], seed[0]);
+}
+

Surely this is going to reduce the 6× slowdown to at least something like 2×, right?

Why does rapidhash even use three independent chains in the first place? That’s right, latency!

mix has a 5 tick latency on modern x86 processors, but a throughput of 1. Chain independence allows a 16-byte block to be consumed without waiting for the previous 16 bytes to be mixed in. We just threw this optimization out.

AccumulationOkay, so padding is a terrible idea. Can we accumulate a buffer instead? How much hashes I had to scroll through in SMHasher before I found one Rust implementation that took this approach is a warning bell.

The implementation I found, of course, stores a Vec<u8> and passes it to the underlying hasher in finish. I believe I don’t need to explain why allocating during hash function is not the brightest idea.

Let’s consider another implementation that stores a fixed-size buffer instead. Huh, that’s a lot of ifs and fors. I wonder what Godbolt will say about this. Let’s try something very simple:

struct StreamingHasher {
+    block_hasher: BlockHasher,
+    buffer: [u8; 8],
+    length: usize,
+}
+
+impl StreamingHasher {
+    fn write(&mut self, input: &[u8]) {
+        // If the input fits in the free space in the buffer, just copy it.
+        let rest = unsafe { self.buffer.get_unchecked_mut(self.length..) };
+        if input.len() < rest.len() {
+            rest[..input.len()].copy_from_slice(input);
+            self.length += input.len();
+            return;
+        }
+
+        // Otherwise, copy whatever fits and hash the chunk.
+        let (head, tail) = input.split_at(rest.len());
+        rest.copy_from_slice(head);
+        self.block_hasher.feed(self.buffer);
+
+        // Split the rest of the input into blocks and hash them individually, move the last one
+        // to the buffer.
+        let chunks = tail.array_chunks();
+        let remainder = chunks.remainder();
+        self.buffer[..remainder.len()].copy_from_slice(remainder);
+        self.length = remainder.len();
+        for chunk in chunks {
+            self.block_hasher.feed(*chunk);
+        }
+    }
+}
+

Surely this will compile to good code? :ferrisClueless:

Here’s what writing 1 (one) byte into this hasher compiles to:

write_u8:
+        push    r15
+        push    r14
+        push    r13
+        push    r12
+        push    rbx
+        sub     rsp, 16
+        mov     rbx, rdi
+        mov     byte ptr [rsp + 15], sil
+        mov     r14, qword ptr [rdi + 16]
+        add     rdi, r14
+        add     rdi, 8
+        cmp     r14, 6
+        ja      .LBB0_2
+        mov     byte ptr [rdi], sil
+        mov     r14, qword ptr [rbx + 16]
+        inc     r14
+        jmp     .LBB0_3
+.LBB0_2:
+        lea     r15, [rbx + 8]
+        mov     edx, 8
+        sub     rdx, r14
+        lea     r12, [rsp + rdx]
+        add     r12, 15
+        add     r14, -7
+        lea     rsi, [rsp + 15]
+        mov     r13, qword ptr [rip + memcpy@GOTPCREL]
+        call    r13
+        movabs  rax, 5512829513697402577
+        imul    rax, qword ptr [rbx]
+        add     rax, qword ptr [rbx + 8]
+        mov     qword ptr [rbx], rax
+        mov     rsi, r14
+        and     rsi, -8
+        add     rsi, r12
+        mov     rdi, r15
+        mov     rdx, r14
+        call    r13
+.LBB0_3:
+        mov     qword ptr [rbx + 16], r14
+        add     rsp, 16
+        pop     rbx
+        pop     r12
+        pop     r13
+        pop     r14
+        pop     r15
+        ret
+

Waow, what happened? That’s right, copy_from_slice did! LLVM cannot compile a variable-length copy into anything other than memcpy. Did you write a loop with a guaranteed bound on the iteration count by hand? Too bad, that goes in the memcpy hole.

SipHasherSo crates in the wild do this wrong. How does the built-in Rust hasher handle this? It conveniently doesn’t define write_* – by design, because this important optimization leads to a small increase in compile time. Riiiiiight.

The siphasher crate, though, optimizes the short-length memcpy with bitwise operations. Let’s try it out:

fn write(&mut self, input: u64, input_len: usize) {
+    assert!(input_len <= 8);
+    if input_len != 8 {
+        assert!(input >> (8 * input_len) == 0);
+    }
+
+    // Consume as many inputs as fit.
+    let old_length = self.length;
+    self.buffer |= input << (8 * self.length);
+    self.length += input_len;
+
+    // On overflow, feed the buffer block hasher and initialize the buffer with the tail.
+    if self.length > 8 {
+        self.block_hasher.feed(self.buffer);
+        self.buffer = input >> (8 * (8 - old_length));
+        self.length -= 8;
+    }
+}
+
write_u8:
+        mov     rax, qword ptr [rdi + 16]
+        movzx   ecx, sil
+        lea     edx, [8*rax]
+        lea     rsi, [rax + 1]
+        shlx    rdx, rcx, rdx
+        or      rdx, qword ptr [rdi + 8]
+        mov     qword ptr [rdi + 8], rdx
+        mov     qword ptr [rdi + 16], rsi
+        cmp     rsi, 9
+        jb      .LBB0_2
+        movabs  rsi, 5512829513697402577
+        imul    rsi, qword ptr [rdi]
+        add     rsi, rdx
+        mov     edx, eax
+        add     rax, -7
+        neg     dl
+        mov     qword ptr [rdi], rsi
+        shl     dl, 3
+        shrx    rcx, rcx, rdx
+        mov     qword ptr [rdi + 8], rcx
+        mov     qword ptr [rdi + 16], rax
+.LBB0_2:
+        ret
+

This is kind of better? Now let’s try hashing (u8, u8) like Rust would do:

#[no_mangle]
+fn write_u8_pair(&mut self, pair: (u8, u8)) {
+    self.write(&[pair.0]);
+    self.write(&[pair.1]);
+}
+
write_u8_pair:
+        mov     r8, qword ptr [rdi + 16]
+        movzx   r9d, sil
+        movabs  rax, 5512829513697402577
+        lea     ecx, [8*r8]
+        shlx    rsi, r9, rcx
+        or      rsi, qword ptr [rdi + 8]
+        lea     rcx, [r8 + 1]
+        cmp     rcx, 9
+        jb      .LBB1_2
+        mov     rcx, qword ptr [rdi]
+        imul    rcx, rax
+        add     rcx, rsi
+        mov     qword ptr [rdi], rcx
+        mov     ecx, r8d
+        add     r8, -7
+        neg     cl
+        shl     cl, 3
+        shrx    rsi, r9, rcx
+        mov     rcx, r8
+.LBB1_2:
+        lea     r8d, [8*rcx]
+        movzx   edx, dl
+        shlx    r8, rdx, r8
+        or      r8, rsi
+        lea     rsi, [rcx + 1]
+        mov     qword ptr [rdi + 8], r8
+        mov     qword ptr [rdi + 16], rsi
+        cmp     rcx, 8
+        jb      .LBB1_4
+        imul    rax, qword ptr [rdi]
+        add     rax, r8
+        mov     qword ptr [rdi], rax
+        mov     eax, ecx
+        add     rcx, -7
+        neg     al
+        shl     al, 3
+        shrx    rax, rdx, rax
+        mov     qword ptr [rdi + 8], rax
+        mov     qword ptr [rdi + 16], rcx
+.LBB1_4:
+        ret
+

Waow. So elegant. What went wrong?

In retrospect, the reason is obvious. The two writes can “tear” if the first write fills the buffer to the end. The optimizer does not realize the writes can be combined, so we’re left with this monstrosity.

More generally, the problem is that write_* methods cannot predict the current state of the buffer, so the branches and variable-index accesses cannot be optimized out. And if writes forced the state to a fixed one? Well, that’s equivalent to padding the data to a full block. Eugh.

InliningOkay, but hear me out, surely the state can be predicted if the hash and write_* calls are inlined? Here:

fn hash_u8_pair(pair: (u8, u8)) -> u64 {
+    let mut hasher = Self::new();
+    hasher.write_u8(pair.0);
+    hasher.write_u8(pair.1);
+    hasher.finish()
+}
+
hash_u8_pair:
+        movzx   eax, sil
+        movzx   ecx, dil
+        shl     eax, 8
+        or      eax, ecx
+        ret
+

That’s a nice argument, but let me introduce to you: variable-length collections. Vec<T> is hashed by writing the length and then hashing the elements one by one. Even if the element hashing is somehow vectorized (it’s not, LLVM is a dumdum), nothing after this variable-length collection can be hashed efficiently.

stdSurely someone thought of this problem before? C’mere, take a look at how slices of integers are hashed:

#[inline]
+fn hash_slice<H: Hasher>(data: &[$ty], state: &mut H) {
+    let newlen = mem::size_of_val(data);
+    let ptr = data.as_ptr() as *const u8;
+    // SAFETY: `ptr` is valid and aligned, as this macro is only used
+    // for numeric primitives which have no padding. The new slice only
+    // spans across `data` and is never mutated, and its total size is the
+    // same as the original `data` so it can't be over `isize::MAX`.
+    state.write(unsafe { slice::from_raw_parts(ptr, newlen) })
+}
+

So that’s good.

Meanwhile newtypes are crying in the corner, as #[derive(Hash)] understandably does not apply this optimization to them (nor to structs with multiple fields and tuples), the built-in hasher uses 2.5× worse code than it could even today, which also takes way more space in your instruction cache than necessary.

It can’t be that bad

It canShall we benchmark some code?

use std::any::type_name;
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::time::Instant;
+
+fn time<T: Hash>(obj: T) {
+    let start = Instant::now();
+    let mut hasher = DefaultHasher::new();
+    obj.hash(&mut hasher);
+    let h = hasher.finish();
+    println!("{}: {:?} (-> {h:0x})", type_name::<T>(), start.elapsed());
+}
+
+#[derive(Hash)]
+struct NewType(i32);
+
+fn main() {
+    let n = 100000000;
+    time((0..n).collect::<Vec<i32>>());
+    time((0..n).map(NewType).collect::<Vec<NewType>>());
+}
+

Hashing [i32] transmutes the slice into [u8] and performs a single write call, while hashing [NewType] hashes the elements one by one. This benchmark thus measures the cost of individual calls. Note also that we hash almost 400 MiB of memory. This doesn’t fit in cache, which might hide some inefficiencies. I’m feeling generous.

alloc::vec::Vec<i32>: 117.756736ms (-> 1984796e743a33f5)
+alloc::vec::Vec<ruined_portal::NewType>: 469.774204ms (-> 1984796e743a33f5)
+

Huh, literally 1984.

We get 5× slower code, even though it computes the exact same hash. Let’s try the siphasher crate:

alloc::vec::Vec<i32>: 196.330253ms (-> 95697c476562afec)
+alloc::vec::Vec<ruined_portal::NewType>: 243.031408ms (-> 95697c476562afec)
+

That’s better, though admittedly a 25% difference is still eugh. But keep in mind that this is a cryptographic hash, which takes a lot of time to hash a block. This difference will be exacerbated on non-cryptographic hashes.

rapidhash:

alloc::vec::Vec<i32>: 54.224434ms (-> 1908e25736ad8479)
+alloc::vec::Vec<ruined_portal::NewType>: 278.101368ms (-> 949efa02155c336a)
+

ahash:

alloc::vec::Vec<i32>: 56.262629ms (-> 217325aa736f75a8)
+alloc::vec::Vec<ruined_portal::NewType>: 177.900032ms (-> 4ae6133ab0e0fe9f)
+

highway:

alloc::vec::Vec<i32>: 53.843217ms (-> f2e68b031ff10c02)
+alloc::vec::Vec<ruined_portal::NewType>: 547.520541ms (-> f2e68b031ff10c02)
+

That’s not good. Note that all hashers have about the same performance on Vec<i32>. That’s about the speed of RAM. For small arrays that fits in cache, the difference is even more prominent. (I didn’t verify this, but I am the smartest person in the room and thus am obviously right.)

My goal

(Kinda)What I really want is a general-purpose hash that’s good for most practical purposes and kinda DoS-resistant but not necessarily cryptographic. It needs to perform fast on short inputs, so it can’t be a “real” block hash, but rather something close to rapidhash.

We want:

consume(a,x,y)=mix(x⊕︎a,y⊕︎C).

Right, Rust doesn’t support this. Okay, let’s try another relatively well-known scheme that might be easier to implement. It’s parallel, surely that’ll help?

To hash a 64-bit word sequence (x1,…,x2n), we compute

mix(x1⊕︎a1,x2⊕︎a2)+⋯+mix(x2n−1⊕︎a2n−1,x2n⊕︎a2n),

where (a1,…,a2n) is random data (possibly generated from the seed once), and

mix(x,y)=(x⋅ymod264)⊕︎(x⋅ydiv264).

This is a combination of certain well-known primitives. The problem here is that ai needs to be precomputed beforehand. This is not a problem for fixed-length keys, like structs of integers – something often used in, say, rustc.

Unfortunately, Rust forces each hasher to handle all possible inputs, including of different lengths, so this scheme can’t work. The hasher isn’t even parametrized by the type of the hashed object. Four well-layouted 64-bit integers that can easily be mixed together with just two full-width multiplications? Nah, write_u64 goes brrrrrrrrrrrr-

Stop bitchingI’ve been designing fast hash-based data structures for several months before realizing they are almost unusable because of these design decisions. Surely something that isn’t a problem in C++ and Python won’t be a problem in Rust, I thought. I deserve a little bitching, okay?

Actually howThe obvious way forward is to bring the structure of the data back into the picture. If the hasher knew it’s hashing fixed-size data, it could use the ai approach. If the hasher knew it’s hashing an array, it could vectorize the computation of individual hashes. If the hasher knew the types of the fields in the structure it’s hashing, it could prevent tearing, or perhaps merge small fields into 64-bit blocks efficiently. Alas, the hasher is clueless…

In my opinion, Hasher and Hash are a wrong abstraction. Instead of the Hash driving the Hasher insane, it should be the other way round: Hash providing introspection facilities and Hasher navigating the hashed objects recursively.

How this API should look like and whether it can be shoehorned into the existing interfaces remains to be seen. I have not started work on the design yet, and perhaps this article might be a bit premature, but I’d love to hear your thoughts on how I missed something really obvious (or, indeed, on how Rust is fast enough and no one cares).

\ No newline at end of file diff --git a/blog/thoughts-on-rust-hashing/index.md b/blog/thoughts-on-rust-hashing/index.md new file mode 100644 index 0000000..b3ba906 --- /dev/null +++ b/blog/thoughts-on-rust-hashing/index.md @@ -0,0 +1,531 @@ +--- +title: Thoughts on Rust hashing +time: December 11, 2024 +intro: | + In languages like Python, Java, or C++, values are hashed by calling a "hash me" method on them, implemented by the type author. This fixed-hash size is then immediately used by the hash table or what have you. This design suffers from some obvious problems, like: + + How do you hash an integer? If you use a no-op hasher (booo), DoS attacks on hash tables are inevitable. If you hash it thoroughly, consumers that only cache hashes to optimize equality checks lose out of performance. +--- + +### Intro + +In languages like Python, Java, or C++, values are hashed by calling a "hash me" method on them, implemented by the type author. This fixed-hash size is then immediately used by the hash table or what have you. This design suffers from some obvious problems, like: + +How do you hash an integer? If you use a no-op hasher (booo), DoS attacks on hash tables are inevitable. If you hash it thoroughly, consumers that only cache hashes to optimize equality checks lose out of performance. + +How do you mix hashes? You can: + +- Leave that to the users. Everyone will then invent their own terrible mixers, like `x ^ y`. Indeed, both arguments are pseudo-random, what could possibly go wrong? +- Provide a good-enough mixer for most use cases, like `a * x + y`. Cue CVEs because people used `mix(x, mix(y, z))` instead of `mix(mix(x, y), z)`. +- Provide a quality mixer, missing out on performance in common simple cases. + +What if the input data is already random? Then you're just wasting cycles. + +What guarantees do you provide regarding the hash values? + +- Do you require the avalanche effect? Your hash is suboptimal even for simple power-of-two-sized hash tables. +- Do you require a half-avalanche effect instead? Congrats, you broke either those or prime-sized hash tables. +- Do you require the hash table to perform finalization manually? Using strings as keys is now suboptimal, because computing a non-finalized hash of a string is of good enough quality already. + +Is your hash function seeded? + +- If not, hi DoS. +- If yes, but you reuse the same seed between different hash tables, [your tables are now quadratic](https://accidentallyquadratic.tumblr.com/post/153545455987/rust-hash-iteration-reinsertion). +- If the seed is explicitly passed to each hasher, how do you ensure different hashers don't accidentally cancel out? + + +### In Rust + +Rust learnt from these mistakes by splitting the responsibilities: + +- Objects implement the `Hash` trait, allowing them to write underlying data into a `Hasher`. +- Hashers implement the `Hasher` trait, which hashes the data written by `Hash` objects. + +Objects turn the structured data into a stream of integers; hashers turn the stream into a numeric hash. + +On paper, this is a good solution: + +- Hashing an integer is as simple as sending the integer to the hasher. Consumers can choose hashers that provide the necessary guarantees. +- Users don't have to mix hashes. Hashers can do that optimally. +- If the data is known to be random, a fast simple hasher can be used without changing the `Hash` implementation. +- Different hash tables can use different hashers, efficiently providing only as much avalanche as necessary. +- The hasher can be seeded per-table. Only the hasher has access to the seed, so safely using the seed during mixing is easy. + +Surely this enables optimal and performant hashing in practice, right? + + +### No + +Let's take a look at the `Hasher` API: + +```rust +pub trait Hasher { + // Required methods + fn finish(&self) -> u64; + fn write(&mut self, bytes: &[u8]); + + // Provided methods + fn write_u8(&mut self, i: u8) { ... } + fn write_u16(&mut self, i: u16) { ... } + fn write_u32(&mut self, i: u32) { ... } + fn write_u64(&mut self, i: u64) { ... } + fn write_u128(&mut self, i: u128) { ... } + fn write_usize(&mut self, i: usize) { ... } + fn write_i8(&mut self, i: i8) { ... } + fn write_i16(&mut self, i: i16) { ... } + fn write_i32(&mut self, i: i32) { ... } + fn write_i64(&mut self, i: i64) { ... } + fn write_i128(&mut self, i: i128) { ... } + fn write_isize(&mut self, i: isize) { ... } + fn write_length_prefix(&mut self, len: usize) { ... } + fn write_str(&mut self, s: &str) { ... } +} +``` + +This API is tuned to *streaming hashes*, like the polynomial hash and its various knock-offs. But just like in encryption, hashing is block-wise these days. + +Block hashes have some internal state that iteratively "absorbs" input blocks of a fixed length. When the data runs out, the last block is padded with length and absorbed as a fixed-length block too. A finalization step then reduces the internal state to 64 bits (or more, depending on the use case). + +That's how SHA-2 and many other cryptographic hashes work, but you might be surprised to know that the top hashes [in the SMHasher list](https://gitlab.com/fwojcik/smhasher3/-/tree/main/results) all use the same approach. + +The block-wise design is objectively superior to streaming. Consuming as much data as possible at once reduces the amortized avalanche cost, enabling safer hash functions at greater speed than streaming hashes can achieve. Block-wise hashes have a lower latency, as the latency is accumulated per-block, not per-stream-input. + + +## Block hash support in Rust + +### :ferrisClueless: + +The `Hasher` API makes no effort to suit block hashes. The hasher is not informed of the length of the data or of its structure. It must *always* be able to absorb just one more `u8`, bro, I promise. There's only two ways to deal with this: + +- Either you pad all individual inputs, even very short ones, to the full block width, +- Or you accumulate a block and occasionally flush it to the underlying block hasher. + +Let's see what's wrong with these approaches. + + +### Padding + +Let's consider a very simple block-wise hash: + +```rust +fn absorb(state: &mut u64, block: &[u8; 8]) { + let block = u64::from_ne_bytes(*block); + *state = state.wrapping_mul(K).wrapping_add(block); +} +``` + +This is just a multiplicative hash, not unlike FNV-1, but consuming $8$ bytes at a time instead of $1$. + +Now what happens if you try to hash two 32-bit integers with this hash? With padding, that will compile to two multiplications even though one would work. This halves throughput and increases latency. + +Practical hashes uses much larger blocks. `rapidhash` has a $24$-byte state and can absorb $48$ bytes at once. `ahash` has a $48$-byte state and absorbs $64$-byte blocks. `meowhash` has a $128$-byte state and absorbs $256$ bytes. (I only selected these particular hashes because I'm familiar with their kernels; others have similar designs.) + +These are some of the fastest non-cryptographic hashes in the world. Do you really want to nuke their performance by padding $8$-byte inputs to $48$, $64$, or $256$ bytes? Probably not. + + +### Chains + +Okay, but what if we cheated and modified the hash functions to absorb small data somewhat more efficiently than absorbing a full block? + +Say, the `rapidhash` kernel is effectively *this*: + +```rust +fn absorb(state: &mut [u64; 3], seed: &[u64; 3], block: &[u64; 6]) { + for i in 0..3 { + state[i] = mix(block[i] ^ state[i], block[i + 3] ^ seed[i]); + } +} +``` + +That's three independent iterations, so *surely* we can absorb a smaller 64-bit block like this instead: + +```rust +fn absorb_64bit(state: &mut [u64; 3], seed: &[u64; 3], block: u64) { + state[0] = mix(block ^ state[0], seed[0]); +} +``` + +Surely this is going to reduce the $6 \times$ slowdown to at least something like $2 \times$, right? + +Why does `rapidhash` even use three independent chains in the first place? That's right, latency! + +`mix` has a $5$ tick latency on modern x86 processors, but a throughput of $1$. Chain independence allows a $16$-byte block to be consumed without waiting for the previous $16$ bytes to be mixed in. We just threw this optimization out. + + +### Accumulation + +Okay, so padding is a terrible idea. Can we accumulate a buffer instead? How much hashes I had to scroll through in SMHasher before I found *one* Rust implementation that took this approach is a warning bell. + +[The implementation I found](https://docs.rs/farmhash/1.1.5/src/farmhash/lib.rs.html#92-110), of course, stores a `Vec` and passes it to the underlying hasher in `finish`. I believe I don't need to explain why allocating during hash function is not the brightest idea. + +Let's consider [another implementation](https://docs.rs/highway/1.2.0/src/highway/portable.rs.html#272-288) that stores a fixed-size buffer instead. Huh, that's a lot of `if`s and `for`s. I wonder what Godbolt will say about this. Let's try something very simple: + +```rust expansible +struct StreamingHasher { + block_hasher: BlockHasher, + buffer: [u8; 8], + length: usize, +} + +impl StreamingHasher { + fn write(&mut self, input: &[u8]) { + // If the input fits in the free space in the buffer, just copy it. + let rest = unsafe { self.buffer.get_unchecked_mut(self.length..) }; + if input.len() < rest.len() { + rest[..input.len()].copy_from_slice(input); + self.length += input.len(); + return; + } + + // Otherwise, copy whatever fits and hash the chunk. + let (head, tail) = input.split_at(rest.len()); + rest.copy_from_slice(head); + self.block_hasher.feed(self.buffer); + + // Split the rest of the input into blocks and hash them individually, move the last one + // to the buffer. + let chunks = tail.array_chunks(); + let remainder = chunks.remainder(); + self.buffer[..remainder.len()].copy_from_slice(remainder); + self.length = remainder.len(); + for chunk in chunks { + self.block_hasher.feed(*chunk); + } + } +} +``` + +Surely this will compile to good code? :ferrisClueless: + +Here's what writing 1 (one) byte into this hasher compiles to: + +```x86asm expansible +write_u8: + push r15 + push r14 + push r13 + push r12 + push rbx + sub rsp, 16 + mov rbx, rdi + mov byte ptr [rsp + 15], sil + mov r14, qword ptr [rdi + 16] + add rdi, r14 + add rdi, 8 + cmp r14, 6 + ja .LBB0_2 + mov byte ptr [rdi], sil + mov r14, qword ptr [rbx + 16] + inc r14 + jmp .LBB0_3 +.LBB0_2: + lea r15, [rbx + 8] + mov edx, 8 + sub rdx, r14 + lea r12, [rsp + rdx] + add r12, 15 + add r14, -7 + lea rsi, [rsp + 15] + mov r13, qword ptr [rip + memcpy@GOTPCREL] + call r13 + movabs rax, 5512829513697402577 + imul rax, qword ptr [rbx] + add rax, qword ptr [rbx + 8] + mov qword ptr [rbx], rax + mov rsi, r14 + and rsi, -8 + add rsi, r12 + mov rdi, r15 + mov rdx, r14 + call r13 +.LBB0_3: + mov qword ptr [rbx + 16], r14 + add rsp, 16 + pop rbx + pop r12 + pop r13 + pop r14 + pop r15 + ret +``` + +Waow, what happened? That's right, `copy_from_slice` did! LLVM *cannot* compile a variable-length copy into anything other than `memcpy`. Did you write a loop with a guaranteed bound on the iteration count by hand? Too bad, that goes in the `memcpy` hole. + + +### SipHasher + +So crates in the wild do this wrong. How does the built-in Rust hasher handle this? [It conveniently doesn't define `write_*`](https://github.com/rust-lang/rust/pull/69152) -- by design, because this important optimization leads to a small increase in compile time. Riiiiiight. + +The `siphasher` *crate*, though, optimizes the short-length `memcpy` with [bitwise operations](https://docs.rs/siphasher/latest/src/siphasher/sip.rs.html#330-354). Let's try it out: + +```rust expansible +fn write(&mut self, input: u64, input_len: usize) { + assert!(input_len <= 8); + if input_len != 8 { + assert!(input >> (8 * input_len) == 0); + } + + // Consume as many inputs as fit. + let old_length = self.length; + self.buffer |= input << (8 * self.length); + self.length += input_len; + + // On overflow, feed the buffer block hasher and initialize the buffer with the tail. + if self.length > 8 { + self.block_hasher.feed(self.buffer); + self.buffer = input >> (8 * (8 - old_length)); + self.length -= 8; + } +} +``` + +```x86asm expansible +write_u8: + mov rax, qword ptr [rdi + 16] + movzx ecx, sil + lea edx, [8*rax] + lea rsi, [rax + 1] + shlx rdx, rcx, rdx + or rdx, qword ptr [rdi + 8] + mov qword ptr [rdi + 8], rdx + mov qword ptr [rdi + 16], rsi + cmp rsi, 9 + jb .LBB0_2 + movabs rsi, 5512829513697402577 + imul rsi, qword ptr [rdi] + add rsi, rdx + mov edx, eax + add rax, -7 + neg dl + mov qword ptr [rdi], rsi + shl dl, 3 + shrx rcx, rcx, rdx + mov qword ptr [rdi + 8], rcx + mov qword ptr [rdi + 16], rax +.LBB0_2: + ret +``` + +This is kind of better? Now let's try hashing `(u8, u8)` like Rust would do: + +```rust +#[no_mangle] +fn write_u8_pair(&mut self, pair: (u8, u8)) { + self.write(&[pair.0]); + self.write(&[pair.1]); +} +``` + +```x86asm expansible +write_u8_pair: + mov r8, qword ptr [rdi + 16] + movzx r9d, sil + movabs rax, 5512829513697402577 + lea ecx, [8*r8] + shlx rsi, r9, rcx + or rsi, qword ptr [rdi + 8] + lea rcx, [r8 + 1] + cmp rcx, 9 + jb .LBB1_2 + mov rcx, qword ptr [rdi] + imul rcx, rax + add rcx, rsi + mov qword ptr [rdi], rcx + mov ecx, r8d + add r8, -7 + neg cl + shl cl, 3 + shrx rsi, r9, rcx + mov rcx, r8 +.LBB1_2: + lea r8d, [8*rcx] + movzx edx, dl + shlx r8, rdx, r8 + or r8, rsi + lea rsi, [rcx + 1] + mov qword ptr [rdi + 8], r8 + mov qword ptr [rdi + 16], rsi + cmp rcx, 8 + jb .LBB1_4 + imul rax, qword ptr [rdi] + add rax, r8 + mov qword ptr [rdi], rax + mov eax, ecx + add rcx, -7 + neg al + shl al, 3 + shrx rax, rdx, rax + mov qword ptr [rdi + 8], rax + mov qword ptr [rdi + 16], rcx +.LBB1_4: + ret +``` + +Waow. So elegant. What went wrong? + +In retrospect, the reason is obvious. The two writes can "tear" if the first write fills the buffer to the end. The optimizer does not realize the writes can be combined, so we're left with this monstrosity. + +More generally, the problem is that `write_*` methods cannot predict the current state of the buffer, so the branches and variable-index accesses cannot be optimized out. And if `write`s forced the state to a fixed one? Well, that's equivalent to padding the data to a full block. Eugh. + + +### Inlining + +Okay, but hear me out, *surely* the state can be predicted if the `hash` and `write_*` calls are inlined? Here: + +```rust +fn hash_u8_pair(pair: (u8, u8)) -> u64 { + let mut hasher = Self::new(); + hasher.write_u8(pair.0); + hasher.write_u8(pair.1); + hasher.finish() +} +``` + +```x86asm +hash_u8_pair: + movzx eax, sil + movzx ecx, dil + shl eax, 8 + or eax, ecx + ret +``` + +That's a nice argument, but let me introduce to you: variable-length collections. `Vec` is hashed by writing the length and then hashing the elements one by one. Even if the element hashing is somehow vectorized (it's not, LLVM is a dumdum), nothing *after* this variable-length collection can be hashed efficiently. + + +### std + +*Surely* someone thought of this problem before? C'mere, take a look at how slices of integers [are hashed](https://doc.rust-lang.org/src/core/hash/mod.rs.html#818-827): + +```rust +#[inline] +fn hash_slice(data: &[$ty], state: &mut H) { + let newlen = mem::size_of_val(data); + let ptr = data.as_ptr() as *const u8; + // SAFETY: `ptr` is valid and aligned, as this macro is only used + // for numeric primitives which have no padding. The new slice only + // spans across `data` and is never mutated, and its total size is the + // same as the original `data` so it can't be over `isize::MAX`. + state.write(unsafe { slice::from_raw_parts(ptr, newlen) }) +} +``` + +So that's good. + +Meanwhile newtypes are crying in the corner, as `#[derive(Hash)]` understandably does not apply this optimization to them (nor to structs with multiple fields and tuples), the built-in hasher uses $2.5 \times$ worse code than it could even today, which *also* takes way more space in your instruction cache than necessary. + + +## It can't be that bad + +### It can + +Shall we benchmark some code? + +```rust +use std::any::type_name; +use std::hash::{DefaultHasher, Hash, Hasher}; +use std::time::Instant; + +fn time(obj: T) { + let start = Instant::now(); + let mut hasher = DefaultHasher::new(); + obj.hash(&mut hasher); + let h = hasher.finish(); + println!("{}: {:?} (-> {h:0x})", type_name::(), start.elapsed()); +} + +#[derive(Hash)] +struct NewType(i32); + +fn main() { + let n = 100000000; + time((0..n).collect::>()); + time((0..n).map(NewType).collect::>()); +} +``` + +Hashing `[i32]` transmutes the slice into `[u8]` and performs a single `write` call, while hashing `[NewType]` hashes the elements one by one. This benchmark thus measures the cost of individual calls. Note also that we hash almost $400$ MiB of memory. This doesn't fit in cache, which might *hide* some inefficiencies. I'm feeling generous. + +``` +alloc::vec::Vec: 117.756736ms (-> 1984796e743a33f5) +alloc::vec::Vec: 469.774204ms (-> 1984796e743a33f5) +``` + +~~Huh, literally 1984.~~ + +We get $5 \times$ slower code, even though it computes the exact same hash. Let's try the `siphasher` crate: + +``` +alloc::vec::Vec: 196.330253ms (-> 95697c476562afec) +alloc::vec::Vec: 243.031408ms (-> 95697c476562afec) +``` + +That's better, though admittedly a $25\%$ difference is still eugh. But keep in mind that this is a *cryptographic* hash, which takes *a lot* of time to hash a block. This difference will be exacerbated on non-cryptographic hashes. + +`rapidhash`: + +``` +alloc::vec::Vec: 54.224434ms (-> 1908e25736ad8479) +alloc::vec::Vec: 278.101368ms (-> 949efa02155c336a) +``` + +`ahash`: + +``` +alloc::vec::Vec: 56.262629ms (-> 217325aa736f75a8) +alloc::vec::Vec: 177.900032ms (-> 4ae6133ab0e0fe9f) +``` + +`highway`: + +``` +alloc::vec::Vec: 53.843217ms (-> f2e68b031ff10c02) +alloc::vec::Vec: 547.520541ms (-> f2e68b031ff10c02) +``` + +That's not good. Note that all hashers have about the same performance on `Vec`. That's about the speed of RAM. For small arrays that fits in cache, the difference is even more prominent. (I didn't verify this, but I am the smartest person in the room and thus am obviously right.) + + +## My goal + +### (Kinda) + +What I really want is a general-purpose hash that's good for most practical purposes and kinda DoS-resistant but not necessarily cryptographic. It needs to perform fast on short inputs, so it can't be a "real" block hash, but rather something close to `rapidhash`. + +We want: + +$$ +\mathrm{consume}(a, x, y) = \mathrm{mix}(x \oplus a, y \oplus C). +$$ + +Right, Rust doesn't support this. Okay, let's try another relatively well-known scheme that might be easier to implement. It's parallel, surely that'll help? + +To hash a $64$-bit word sequence $(x_1, \dots, x_{2n})$, we compute + +$$ +\mathrm{mix}(x_1 \oplus a_1, x_2 \oplus a_2) + \dots + \mathrm{mix}(x_{2n - 1} \oplus a_{2n - 1}, x_{2n} \oplus a_{2n}), +$$ + +where $(a_1, \dots, a_{2n})$ is random data (possibly generated from the seed once), and + +$$ +\mathrm{mix}(x, y) = (x \cdot y \bmod 2^{64}) \oplus (x \cdot y \mathop{div} 2^{64}). +$$ + +This is a combination of certain well-known primitives. The problem here is that $a_i$ needs to be precomputed beforehand. This is not a problem for fixed-length keys, like structs of integers -- something often used in, say, `rustc`. + +Unfortunately, Rust forces each hasher to handle *all* possible inputs, including of different lengths, so this scheme can't work. The hasher isn't even parametrized by the type of the hashed object. Four well-layouted 64-bit integers that can easily be mixed together with just two full-width multiplications? Nah, `write_u64` goes brrrrrrrrrrrr- + + +### Stop bitching + +I've been designing fast hash-based data structures for several months before realizing they are almost unusable because of these design decisions. *Surely* something that isn't a problem in C++ and Python won't be a problem in Rust, I thought. I deserve a little bitching, okay? + + +### Actually how + +The obvious way forward is to bring the structure of the data back into the picture. If the hasher knew it's hashing fixed-size data, it could use the $a_i$ approach. If the hasher knew it's hashing an array, it could vectorize the computation of individual hashes. If the hasher knew the types of the fields in the structure it's hashing, it could prevent tearing, or perhaps merge small fields into 64-bit blocks efficiently. Alas, the hasher is clueless... + +In my opinion, `Hasher` and `Hash` are a wrong abstraction. Instead of the `Hash` driving the `Hasher` ~~insane~~, it should be the other way round: `Hash` providing introspection facilities and `Hasher` navigating the hashed objects recursively. + +How this API should look like and whether it can be shoehorned into the existing interfaces remains to be seen. I have not started work on the design yet, and perhaps this article might be a bit premature, but I'd love to hear your thoughts on how I missed something really obvious (or, indeed, on how Rust is fast enough and no one cares). diff --git a/blog/thoughts-on-rust-hashing/og.png b/blog/thoughts-on-rust-hashing/og.png new file mode 100644 index 0000000000000000000000000000000000000000..1897d7c0b3f038b38b64ffe0b4a19319d515d3f0 GIT binary patch literal 113108 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