rapidhash 4.4.1

An extremely fast, high quality, platform-independent hashing algorithm.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Internal module for reading unaligned bytes from a slice into `u64` and `u32` values.
//!
//! This is a non-portable implementation specifically designed for `RapidHasher`.

/// A macro for assertions that can be disabled with the `unsafe` feature. These should all be
/// elided at compile-time anyway.
macro_rules! unsafe_assert {
    ($cond:expr) => {
        #[cfg(feature = "unsafe")]
        {
            debug_assert!($cond);
        }

        #[cfg(not(feature = "unsafe"))]
        {
            assert!($cond);
        }
    };
}

/// Unsafe but const-friendly unaligned bytes to u64. The compiler can't seem to remove the bounds
/// checks for small integers because we do some funky bit shifting in the indexing.
///
/// SAFETY: `slice` must be at least `offset+8` bytes long, which we guarantee in this rapidhash
/// implementation.
#[inline(always)]
pub(crate) const fn read_u64_np(slice: &[u8], offset: usize) -> u64 {
    unsafe_assert!(slice.len() >= 8 + offset);
    // SAFETY: read_u64_np must always be called in a manner that guarantees the above assertions
    unsafe { core::ptr::read_unaligned(slice.as_ptr().add(offset) as *const u64) }
}

/// Unsafe but const-friendly unaligned bytes to u32. The compiler can't seem to remove the bounds
/// checks for small integers because we do some funky bit shifting in the indexing.
///
/// SAFETY: `slice` must be at least `offset+8` bytes long, which we guarantee in this rapidhash
/// implementation.
#[inline(always)]
pub(crate) const fn read_u32_np(slice: &[u8], offset: usize) -> u32 {
    unsafe_assert!(slice.len() >= 4 + offset);
    // SAFETY: read_u64_np must always be called in a manner that guarantees the above assertions
    unsafe { core::ptr::read_unaligned(slice.as_ptr().add(offset) as *const u32) }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[cfg(target_endian = "little")]
    #[test]
    fn test_read_u32_np() {
        let bytes = &[23, 145, 3, 34];
        assert_eq!(read_u32_np(bytes, 0), 570659095);

        let bytes = &[24, 54, 3, 23, 145, 3, 34];
        assert_eq!(read_u32_np(bytes, 3), 570659095);

        assert_eq!(read_u32_np(&[0, 0, 0, 0], 0), 0);
        assert_eq!(read_u32_np(&[1, 0, 0, 0], 0), 1);
        assert_eq!(read_u32_np(&[12, 0, 0, 0], 0), 12);
        assert_eq!(read_u32_np(&[0, 10, 0, 0], 0), 2560);
    }

    #[cfg(target_endian = "little")]
    #[test]
    fn test_read_u64_np() {
        let bytes = [23, 145, 3, 34, 0, 0, 0, 0, 0, 0, 0].as_slice();
        assert_eq!(read_u64_np(bytes, 0), 570659095);

        let bytes = [1, 2, 3, 23, 145, 3, 34, 0, 0, 0, 0, 0, 0, 0].as_slice();
        assert_eq!(read_u64_np(bytes, 3), 570659095);

        let bytes = [0, 0, 0, 0, 0, 0, 0, 0].as_slice();
        assert_eq!(read_u64_np(bytes, 0), 0);
    }

    #[cfg(target_endian = "little")]
    #[cfg(feature = "std")]
    #[test]
    fn test_u32_to_u128_delta() {
        fn formula(len: u64) -> u64 {
            (len & 24) >> (len >> 3)
        }

        fn formula2(len: u64) -> u64 {
            match len {
                8.. => 4,
                _ => 0,
            }
        }

        let inputs: std::vec::Vec<u64> = (4..=16).collect();
        let outputs: std::vec::Vec<u64> = inputs.iter().map(|&x| formula(x)).collect();
        let expected = std::vec![0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4];
        assert_eq!(outputs, expected);
        assert_eq!(outputs, inputs.iter().map(|&x| formula2(x)).collect::<Vec<u64>>());
    }

    #[test]
    #[should_panic]
    #[cfg(any(test, not(feature = "unsafe")))]
    fn test_read_u32_np_to_short_panics() {
        let bytes = [23, 145, 0].as_slice();
        assert_eq!(read_u32_np(bytes, 0), 0);
    }

    #[test]
    #[should_panic]
    #[cfg(any(test, not(feature = "unsafe")))]
    fn test_read_u64_np_to_short_panics() {
        let bytes = [23, 145, 0].as_slice();
        assert_eq!(read_u64_np(bytes, 0), 0);
    }
}