EIC code displayed by LXR master/​include/​boost/​hash2/​legacy/​spooky2.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-09-17 08:33:43

 #ifndef BOOST_HASH2_SPOOKY2_HPP_INCLUDED
 #define BOOST_HASH2_SPOOKY2_HPP_INCLUDED
 
 // Copyright 2017, 2018 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 //
 // SpookyHash V2, http://burtleburtle.net/bob/hash/spooky.html
 
 #include <boost/hash2/detail/read.hpp>
 #include <boost/hash2/detail/write.hpp>
 #include <boost/hash2/detail/rot.hpp>
 #include <boost/assert.hpp>
 #include <cstdint>
 #include <array>
 #include <utility>
 #include <cstring>
 
 namespace boost
 {
 namespace hash2
 {
 
 class spooky2_128
 {
 private:
 
     static const std::uint64_t sc_const = 0xdeadbeefdeadbeefULL;
 
 private:
 
     static const int M = 12;
     std::uint64_t v_[ M ];
 
     static const int N = 192;
     unsigned char buffer_[ N ];
 
     std::size_t m_; // == n_ % N
 
     std::size_t n_;
 
 private:
 
     static inline void short_mix( std::uint64_t & h0, std::uint64_t & h1, std::uint64_t & h2, std::uint64_t & h3 )
     {
         h2 = detail::rotl( h2, 50 ); h2 += h3; h0 ^= h2;
         h3 = detail::rotl( h3, 52 ); h3 += h0; h1 ^= h3;
         h0 = detail::rotl( h0, 30 ); h0 += h1; h2 ^= h0;
         h1 = detail::rotl( h1, 41 ); h1 += h2; h3 ^= h1;
         h2 = detail::rotl( h2, 54 ); h2 += h3; h0 ^= h2;
         h3 = detail::rotl( h3, 48 ); h3 += h0; h1 ^= h3;
         h0 = detail::rotl( h0, 38 ); h0 += h1; h2 ^= h0;
         h1 = detail::rotl( h1, 37 ); h1 += h2; h3 ^= h1;
         h2 = detail::rotl( h2, 62 ); h2 += h3; h0 ^= h2;
         h3 = detail::rotl( h3, 34 ); h3 += h0; h1 ^= h3;
         h0 = detail::rotl( h0,  5 ); h0 += h1; h2 ^= h0;
         h1 = detail::rotl( h1, 36 ); h1 += h2; h3 ^= h1;
     }
 
     static inline void short_end( std::uint64_t & h0, std::uint64_t & h1, std::uint64_t & h2, std::uint64_t & h3 )
     {
         h3 ^= h2; h2 = detail::rotl( h2, 15 ); h3 += h2;
         h0 ^= h3; h3 = detail::rotl( h3, 52 ); h0 += h3;
         h1 ^= h0; h0 = detail::rotl( h0, 26 ); h1 += h0;
         h2 ^= h1; h1 = detail::rotl( h1, 51 ); h2 += h1;
         h3 ^= h2; h2 = detail::rotl( h2, 28 ); h3 += h2;
         h0 ^= h3; h3 = detail::rotl( h3,  9 ); h0 += h3;
         h1 ^= h0; h0 = detail::rotl( h0, 47 ); h1 += h0;
         h2 ^= h1; h1 = detail::rotl( h1, 54 ); h2 += h1;
         h3 ^= h2; h2 = detail::rotl( h2, 32 ); h3 += h2;
         h0 ^= h3; h3 = detail::rotl( h3, 25 ); h0 += h3;
         h1 ^= h0; h0 = detail::rotl( h0, 63 ); h1 += h0;
     }
 
     static void short_hash( unsigned char const * p, std::size_t n, std::uint64_t & hash1, std::uint64_t & hash2 )
     {
         std::uint64_t a = hash1;
         std::uint64_t b = hash2;
         std::uint64_t c = sc_const;
         std::uint64_t d = sc_const;
 
         std::size_t m = n;
 
         while( m >= 32 )
         {
             c += detail::read64le( p +  0 );
             d += detail::read64le( p +  8 );
 
             short_mix( a, b, c, d );
 
             a += detail::read64le( p + 16 );
             b += detail::read64le( p + 24 );
 
             p += 32;
             m -= 32;
         }
 
         if( m >= 16 )
         {
             c += detail::read64le( p +  0 );
             d += detail::read64le( p +  8 );
 
             short_mix( a, b, c, d );
 
             p += 16;
             m -= 16;
         }
 
         if( m == 0 )
         {
             c += sc_const;
             d += sc_const;
         }
         else
         {
             BOOST_ASSERT( m < 16 );
 
             unsigned char tmp[ 16 ] = { 0 };
             std::memcpy( tmp, p, m );
 
             c += detail::read64le( tmp + 0 );
             d += detail::read64le( tmp + 8 );
         }
 
         d += static_cast<std::uint64_t>( n ) << 56;
 
         short_end( a, b, c, d );
 
         hash1 = a;
         hash2 = b;
     }
 
 private:
 
     static inline void mix( unsigned char const * p,
         std::uint64_t & s0, std::uint64_t & s1, std::uint64_t &  s2, std::uint64_t &  s3,
         std::uint64_t & s4, std::uint64_t & s5, std::uint64_t &  s6, std::uint64_t &  s7,
         std::uint64_t & s8, std::uint64_t & s9, std::uint64_t & s10, std::uint64_t & s11 )
     {
         s0  += detail::read64le( p +  0 ); s2  ^= s10; s11 ^= s0;  s0  = detail::rotl( s0,  11 ); s11 += s1;
         s1  += detail::read64le( p +  8 ); s3  ^= s11; s0  ^= s1;  s1  = detail::rotl( s1,  32 ); s0  += s2;
         s2  += detail::read64le( p + 16 ); s4  ^= s0;  s1  ^= s2;  s2  = detail::rotl( s2,  43 ); s1  += s3;
         s3  += detail::read64le( p + 24 ); s5  ^= s1;  s2  ^= s3;  s3  = detail::rotl( s3,  31 ); s2  += s4;
         s4  += detail::read64le( p + 32 ); s6  ^= s2;  s3  ^= s4;  s4  = detail::rotl( s4,  17 ); s3  += s5;
         s5  += detail::read64le( p + 40 ); s7  ^= s3;  s4  ^= s5;  s5  = detail::rotl( s5,  28 ); s4  += s6;
         s6  += detail::read64le( p + 48 ); s8  ^= s4;  s5  ^= s6;  s6  = detail::rotl( s6,  39 ); s5  += s7;
         s7  += detail::read64le( p + 56 ); s9  ^= s5;  s6  ^= s7;  s7  = detail::rotl( s7,  57 ); s6  += s8;
         s8  += detail::read64le( p + 64 ); s10 ^= s6;  s7  ^= s8;  s8  = detail::rotl( s8,  55 ); s7  += s9;
         s9  += detail::read64le( p + 72 ); s11 ^= s7;  s8  ^= s9;  s9  = detail::rotl( s9,  54 ); s8  += s10;
         s10 += detail::read64le( p + 80 ); s0  ^= s8;  s9  ^= s10; s10 = detail::rotl( s10, 22 ); s9  += s11;
         s11 += detail::read64le( p + 88 ); s1  ^= s9;  s10 ^= s11; s11 = detail::rotl( s11, 46 ); s10 += s0;
     }
 
     void update_( unsigned char const * p, std::size_t k )
     {
         std::uint64_t h0  = v_[ 0];
         std::uint64_t h1  = v_[ 1];
         std::uint64_t h2  = v_[ 2];
         std::uint64_t h3  = v_[ 3];
         std::uint64_t h4  = v_[ 4];
         std::uint64_t h5  = v_[ 5];
         std::uint64_t h6  = v_[ 6];
         std::uint64_t h7  = v_[ 7];
         std::uint64_t h8  = v_[ 8];
         std::uint64_t h9  = v_[ 9];
         std::uint64_t h10 = v_[10];
         std::uint64_t h11 = v_[11];
 
         for( std::size_t i = 0; i < k; ++i, p += 96 )
         {
             mix( p, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11 );
         }
 
         v_[ 0] = h0;
         v_[ 1] = h1;
         v_[ 2] = h2;
         v_[ 3] = h3;
         v_[ 4] = h4;
         v_[ 5] = h5;
         v_[ 6] = h6;
         v_[ 7] = h7;
         v_[ 8] = h8;
         v_[ 9] = h9;
         v_[10] = h10;
         v_[11] = h11;
     }
 
     static inline void end_partial(
         std::uint64_t & h0, std::uint64_t & h1, std::uint64_t &  h2, std::uint64_t &  h3,
         std::uint64_t & h4, std::uint64_t & h5, std::uint64_t &  h6, std::uint64_t &  h7, 
         std::uint64_t & h8, std::uint64_t & h9, std::uint64_t & h10, std::uint64_t & h11 )
     {
         h11 += h1;    h2  ^= h11;   h1  = detail::rotl( h1,  44 );
         h0  += h2;    h3  ^= h0;    h2  = detail::rotl( h2,  15 );
         h1  += h3;    h4  ^= h1;    h3  = detail::rotl( h3,  34 );
         h2  += h4;    h5  ^= h2;    h4  = detail::rotl( h4,  21);
         h3  += h5;    h6  ^= h3;    h5  = detail::rotl( h5,  38);
         h4  += h6;    h7  ^= h4;    h6  = detail::rotl( h6,  33);
         h5  += h7;    h8  ^= h5;    h7  = detail::rotl( h7,  10);
         h6  += h8;    h9  ^= h6;    h8  = detail::rotl( h8,  13);
         h7  += h9;    h10 ^= h7;    h9  = detail::rotl( h9,  38);
         h8  += h10;   h11 ^= h8;    h10 = detail::rotl( h10, 53);
         h9  += h11;   h0  ^= h9;    h11 = detail::rotl( h11, 42);
         h10 += h0;    h1  ^= h10;   h0  = detail::rotl( h0,  54);
     }
 
     static inline void end( unsigned char const * p,
         std::uint64_t & h0, std::uint64_t & h1, std::uint64_t &  h2, std::uint64_t &  h3,
         std::uint64_t & h4, std::uint64_t & h5, std::uint64_t &  h6, std::uint64_t &  h7, 
         std::uint64_t & h8, std::uint64_t & h9, std::uint64_t & h10, std::uint64_t & h11 )
     {
         h0  += detail::read64le( p +  0 );
         h1  += detail::read64le( p +  8 );
         h2  += detail::read64le( p + 16 );
         h3  += detail::read64le( p + 24 );
         h4  += detail::read64le( p + 32 );
         h5  += detail::read64le( p + 40 );
         h6  += detail::read64le( p + 48 );
         h7  += detail::read64le( p + 56 );
         h8  += detail::read64le( p + 64 );
         h9  += detail::read64le( p + 72 );
         h10 += detail::read64le( p + 80 );
         h11 += detail::read64le( p + 88 );
 
         end_partial( h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11 );
         end_partial( h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11 );
         end_partial( h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11 );
     }
 
     void init( std::uint64_t seed1, std::uint64_t seed2 )
     {
         v_[ 0 ] = v_[ 3 ] = v_[ 6 ] = v_[  9 ] = seed1;
         v_[ 1 ] = v_[ 4 ] = v_[ 7 ] = v_[ 10 ] = seed2;
         v_[ 2 ] = v_[ 5 ] = v_[ 8 ] = v_[ 11 ] = sc_const;
     }
 
 public:
 
     typedef std::array<unsigned char, 16> result_type;
     typedef std::uint64_t size_type;
 
     explicit spooky2_128( std::uint64_t seed1 = 0, std::uint64_t seed2 = 0 ): m_( 0 ), n_( 0 )
     {
         init( seed1, seed2 );
     }
 
     spooky2_128( unsigned char const * p, std::size_t n ): m_( 0 ), n_( 0 )
     {
         if( n == 0 )
         {
             init( 0, 0 );
         }
         else if( n <= 16 )
         {
             unsigned char q[ 18 ] = {};
             std::memcpy( q, p, n );
 
             std::uint64_t seed1 = detail::read64le( q + 0 );
             std::uint64_t seed2 = detail::read64le( q + 8 );
 
             init( seed1, seed2 );
         }
         else
         {
             std::uint64_t seed1 = detail::read64le( p + 0 );
             std::uint64_t seed2 = detail::read64le( p + 8 );
 
             init( seed1, seed2 );
 
             p += 16;
             n -= 16;
 
             update( p, n );
             result();
         }
     }
 
     void update( void const * pv, std::size_t n )
     {
         unsigned char const* p = static_cast<unsigned char const*>( pv );
 
         BOOST_ASSERT( m_ == n_ % N );
 
         if( n == 0 ) return;
 
         n_ += n;
 
         if( m_ > 0 )
         {
             std::size_t k = N - m_;
 
             if( n < k )
             {
                 k = n;
             }
 
             std::memcpy( buffer_ + m_, p, k );
 
             p += k;
             n -= k;
             m_ += k;
 
             if( m_ < N ) return;
 
             BOOST_ASSERT( m_ == N );
 
             update_( buffer_, 2 );
             m_ = 0;
         }
 
         BOOST_ASSERT( m_ == 0 );
 
         {
             std::size_t k = n / N;
 
             update_( p, k * 2 );
 
             p += k * N;
             n -= k * N;
         }
 
         BOOST_ASSERT( n < N );
 
         if( n > 0 )
         {
             std::memcpy( buffer_, p, n );
             m_ = n;
         }
 
         BOOST_ASSERT( m_ == n_ % N );
     }
 
     result_type result()
     {
         BOOST_ASSERT( m_ == n_ % N );
 
         std::uint64_t h0 = v_[ 0 ];
         std::uint64_t h1 = v_[ 1 ];
 
         if( n_ < N )
         {
             short_hash( buffer_, n_, h0, h1 );
         }
         else
         {
             std::uint64_t h2  = v_[  2 ];
             std::uint64_t h3  = v_[  3 ];
             std::uint64_t h4  = v_[  4 ];
             std::uint64_t h5  = v_[  5 ];
             std::uint64_t h6  = v_[  6 ];
             std::uint64_t h7  = v_[  7 ];
             std::uint64_t h8  = v_[  8 ];
             std::uint64_t h9  = v_[  9 ];
             std::uint64_t h10 = v_[ 10 ];
             std::uint64_t h11 = v_[ 11 ];
 
             unsigned char * p = buffer_;
             std::size_t m = m_;
 
             if( m >= 96 )
             {
                 mix( p, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11 );
 
                 p += 96;
                 m -= 96;
             }
 
             std::memset( p + m, 0, 96 - m );
             p[ 95 ] = static_cast<unsigned char>( m & 0xFF );
 
             end( p, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11 );
 
             v_[  2 ] = h2;
             v_[  3 ] = h3;
             v_[  4 ] = h4;
             v_[  5 ] = h5;
             v_[  6 ] = h6;
             v_[  7 ] = h7;
             v_[  8 ] = h8;
             v_[  9 ] = h9;
             v_[ 10 ] = h10;
             v_[ 11 ] = h11;
         }
 
         v_[ 0 ] = h0;
         v_[ 1 ] = h1;
 
         n_ += N - m_;
         m_ = 0;
 
         if( n_ < N )
         {
             n_ = 0; // in case of overflow (N does not divide 2^32)
         }
 
         // clear buffered plaintext
         std::memset( buffer_, 0, N );
 
         result_type r;
 
         detail::write64le( &r[ 0 ], h0 );
         detail::write64le( &r[ 8 ], h1 );
 
         return r;
     }
 };
 
 } // namespace hash2
 } // namespace boost
 
 #endif // #ifndef BOOST_HASH2_SPOOKY2_HPP_INCLUDED

This page was automatically generated by the 2.3.7 LXR engine. The LXR team