quickcpplib::_xxx::algorithm::hash::fast_hash Class Reference

Fast very collision resistant uint128 hash. Currently SpookyHash @ 0.3 cycles/byte. More...

#include "hash.hpp"

Public Types
using	result_type = uint128
	The result type of the hash.

Public Member Functions
constexpr	fast_hash (const uint128 &seed=0) noexcept
	Initialise the hash with an optional seed.
template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>
void	add (const T *message, size_t length) noexcept
	Hash input.
uint128	finalise () noexcept
	Finalise and return hash.

Static Public Member Functions
template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>
static uint128	hash (const T *message, size_t length, const uint128 &_ret=0) noexcept
	Single shot hash of a sequence of bytes.

Detailed Description

Fast very collision resistant uint128 hash. Currently SpookyHash @ 0.3 cycles/byte.

Member Typedef Documentation

result_type

using quickcpplib::_xxx::algorithm::hash::fast_hash::result_type = uint128

The result type of the hash.

Constructor & Destructor Documentation

fast_hash()

constexpr quickcpplib::_xxx::algorithm::hash::fast_hash::fast_hash ( const uint128 &  seed = 0 )

inlineconstexprnoexcept

Initialise the hash with an optional seed.

          : m_data{0}
          , m_state{seed.as_longlongs[0], seed.as_longlongs[1]}
          , m_length(0)
          , m_remainder(0)
      {
      }

Member Function Documentation

add()

template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>

void quickcpplib::_xxx::algorithm::hash::fast_hash::add ( const T *  message, size_t  length  )

inlinenoexcept

Hash input.

      {
        using namespace fash_hash_detail;
        uint64 h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11;
        size_t newLength = length + m_remainder;
        uint8 remainder;
        union
        {
          const uint8 *p8;
          uint64 *p64;
          size_t i;
        } u;
        const uint64 *end;
 
        // Is this message fragment too short?  If it is, stuff it away.
        if(newLength < sc_bufSize)
        {
          memcpy(&((uint8 *) m_data)[m_remainder], message, length);
          m_length = length + m_length;
          m_remainder = (uint8) newLength;
          return;
        }
 
        // init the variables
        if(m_length < sc_bufSize)
        {
          h0 = h3 = h6 = h9 = m_state[0];
          h1 = h4 = h7 = h10 = m_state[1];
          h2 = h5 = h8 = h11 = sc_const;
        }
        else
        {
          h0 = m_state[0];
          h1 = m_state[1];
          h2 = m_state[2];
          h3 = m_state[3];
          h4 = m_state[4];
          h5 = m_state[5];
          h6 = m_state[6];
          h7 = m_state[7];
          h8 = m_state[8];
          h9 = m_state[9];
          h10 = m_state[10];
          h11 = m_state[11];
        }
        m_length = length + m_length;
 
        // if we've got anything stuffed away, use it now
        if(m_remainder)
        {
          uint8 prefix = sc_bufSize - m_remainder;
          memcpy(&(((uint8 *) m_data)[m_remainder]), message, prefix);
          u.p64 = m_data;
          Mix(u.p64, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);
          Mix(&u.p64[sc_numVars], h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);
          u.p8 = ((const uint8 *) message) + prefix;
          length -= prefix;
        }
        else
        {
          u.p8 = (const uint8 *) message;
        }
 
        // handle all whole blocks of sc_blockSize bytes
        end = u.p64 + (length / sc_blockSize) * sc_numVars;
        remainder = (uint8) (length - ((const uint8 *) end - u.p8));
        if(ALLOW_UNALIGNED_READS || (u.i & 0x7) == 0)
        {
          while(u.p64 < end)
          {
            Mix(u.p64, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);
            u.p64 += sc_numVars;
          }
        }
        else
        {
          while(u.p64 < end)
          {
            memcpy(m_data, u.p8, sc_blockSize);
            Mix(m_data, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);
            u.p64 += sc_numVars;
          }
        }
 
        // stuff away the last few bytes
        m_remainder = remainder;
        memcpy(m_data, end, remainder);
 
        // stuff away the variables
        m_state[0] = h0;
        m_state[1] = h1;
        m_state[2] = h2;
        m_state[3] = h3;
        m_state[4] = h4;
        m_state[5] = h5;
        m_state[6] = h6;
        m_state[7] = h7;
        m_state[8] = h8;
        m_state[9] = h9;
        m_state[10] = h10;
        m_state[11] = h11;
      }

finalise()

uint128 quickcpplib::_xxx::algorithm::hash::fast_hash::finalise ( )

inlinenoexcept

Finalise and return hash.

      {
        using namespace fash_hash_detail;
        uint128 ret;
        // init the variables
        if(m_length < sc_bufSize)
        {
          ret.as_longlongs[0] = m_state[0];
          ret.as_longlongs[1] = m_state[1];
          short_(ret, m_data_, m_length);
          return ret;
        }
 
        const uint64 *data = (const uint64 *) m_data;
        uint8 remainder = m_remainder;
 
        uint64 h0 = m_state[0];
        uint64 h1 = m_state[1];
        uint64 h2 = m_state[2];
        uint64 h3 = m_state[3];
        uint64 h4 = m_state[4];
        uint64 h5 = m_state[5];
        uint64 h6 = m_state[6];
        uint64 h7 = m_state[7];
        uint64 h8 = m_state[8];
        uint64 h9 = m_state[9];
        uint64 h10 = m_state[10];
        uint64 h11 = m_state[11];
 
        if(remainder >= sc_blockSize)
        {
          // m_data can contain two blocks; handle any whole first block
          Mix(data, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);
          data += sc_numVars;
          remainder -= sc_blockSize;
        }
 
        // mix in the last partial block, and the length mod sc_blockSize
        memset(&((uint8 *) data)[remainder], 0, (sc_blockSize - remainder));
 
        ((uint8 *) data)[sc_blockSize - 1] = remainder;
 
        // do some final mixing
        End(data, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);
 
        ret.as_longlongs[0] = h0;
        ret.as_longlongs[1] = h1;
        return ret;
      }

hash()

template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>

static uint128 quickcpplib::_xxx::algorithm::hash::fast_hash::hash ( const T *  message, size_t  length, const uint128 &  _ret = 0  )

inlinestaticnoexcept

Single shot hash of a sequence of bytes.

      {
        uint128 ret(_ret);
        using namespace fash_hash_detail;
        if(length < sc_bufSize)
        {
          short_(ret, message, length);
          return ret;
        }
 
        uint64 h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11;
        uint64 buf[sc_numVars];
        uint64 *end;
        union
        {
          const uint8 *p8;
          uint64 *p64;
          size_t i;
        } u;
        size_t remainder;
 
        h0 = h3 = h6 = h9 = ret.as_longlongs[0];
        h1 = h4 = h7 = h10 = ret.as_longlongs[1];
        h2 = h5 = h8 = h11 = sc_const;
 
        u.p8 = (const uint8 *) message;
        end = u.p64 + (length / sc_blockSize) * sc_numVars;
 
        // handle all whole sc_blockSize blocks of bytes
        if(ALLOW_UNALIGNED_READS || ((u.i & 0x7) == 0))
        {
          while(u.p64 < end)
          {
            Mix(u.p64, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);
            u.p64 += sc_numVars;
          }
        }
        else
        {
          while(u.p64 < end)
          {
            memcpy(buf, u.p64, sc_blockSize);
            Mix(buf, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);
            u.p64 += sc_numVars;
          }
        }
 
        // handle the last partial block of sc_blockSize bytes
        remainder = (length - ((const uint8 *) end - (const uint8 *) message));
        memcpy(buf, end, remainder);
        memory::cmemset(((uint8 *) buf) + remainder, (uint8) 0, sc_blockSize - remainder);
        ((uint8 *) buf)[sc_blockSize - 1] = (uint8) remainder;
 
        // do some final mixing
        End(buf, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);
 
        ret.as_longlongs[0] = h0;
        ret.as_longlongs[1] = h1;
        return ret;
      }

Member Data Documentation

m_data_

uint8 quickcpplib::_xxx::algorithm::hash::fast_hash::m_data_[2 *sc_numVars *8]

m_data

uint64 quickcpplib::_xxx::algorithm::hash::fast_hash::m_data[2 *sc_numVars]

---

The documentation for this class was generated from the following file:

• include/quickcpplib/algorithm/hash.hpp