Reproducible Hashes is 0.8?

[domenukk]

We are currently using ahash 0.7 to hash some data we store to disk, as fast as possible, and deduplicate them between different processes (that might be compiled differently, as well).
It doesn't matter if it's attackable, since we are the only users in this case.
So far we have used new_with_keys(key1: u128, key2: u128) -> AHasher with 0, 0 as keys, to create such a reproducible hashes.
However, starting in 0.8 this method is private.

Are we holding it wrong/misunderstanding something?
What would be the fastest way to create such a reproducible ahasher in 0.8 and up?
Even RandomState::with_seed(0).build_hasher(); seems to internally use the keys.

Thank you

[rrichardson]

I am in a similar boat. I've tried setting
default-features = false
then doing :

static HASH_KEY: usize = 12345;

lazy_static! {
    static ref HASH_STATE: RandomState = { 
        set_random_source(NotRandomState).expect("Setting hash state to not-random");
        RandomState::with_seed(HASH_KEY)
    };
}
struct NotRandomState;

impl RandomSource for NotRandomState {
    fn gen_hasher_seed(&self) -> usize {
        HASH_KEY
    }
}

fn hash_stuff(a: A, b: B) -> u64 {
    let mut hasher = HASH_STATE.build_hasher();
    a.hash(&mut hasher);
    b.hash(&mut hasher);
    hasher.finish().into()
}

This seems to produce self-consistent hashes between builds on the same platform.

However, on different platforms (e.g. aarch64) it produces different values.

Is there an easier or more reliable method of ensuring consistencency?

[rrichardson]

@domenukk - digging into the code a bit farther, it seems that using RandomState::with_seeds should achieve the old new_with_keys functionality.

e.g.

let st = RandomState::with_seeds(42, 1, 0 5); 
let hasher = st.build_hasher(); 

build_hasher just calls (private) AHasher::from_random_state (https://docs.rs/ahash/latest/src/ahash/aes_hash.rs.html#73)

However, I still don't get consistency across multiple platforms (and I suspect 0.7 is the same)

[tkaitchuck]

with_seeds is the method you are looking for.
However please note that aHash does not guarantee identical output across architectures, flags, or versions. For example when 0.8.1 is released, it will have performance improvements but the same data will hash to different values than it did in 0.8.0.

[tkaitchuck]

This is now better documented in 0.8.1:
https://docs.rs/ahash/0.8.1/ahash/random_state/struct.RandomState.html