Function hash_bytes

libCacheSim/dataStructure/robin_hood.h:692–746

}

inline size_t hash_bytes(void const* ptr, size_t len) noexcept {
  static constexpr uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
  static constexpr uint64_t seed = UINT64_C(0xe17a1465);
  static constexpr unsigned int r = 47;

  auto const* const data64 = static_cast<uint64_t const*>(ptr);
  uint64_t h = seed ^ (len * m);

  size_t const n_blocks = len / 8;
  for (size_t i = 0; i < n_blocks; ++i) {
    auto k = detail::unaligned_load<uint64_t>(data64 + i);

    k *= m;
    k ^= k >> r;
    k *= m;

    h ^= k;
    h *= m;
  }

  auto const* const data8 = reinterpret_cast<uint8_t const*>(data64 + n_blocks);
  switch (len & 7U) {
    case 7:
      h ^= static_cast<uint64_t>(data8[6]) << 48U;
      ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
    case 6:
      h ^= static_cast<uint64_t>(data8[5]) << 40U;
      ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
    case 5:
      h ^= static_cast<uint64_t>(data8[4]) << 32U;
      ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
    case 4:
      h ^= static_cast<uint64_t>(data8[3]) << 24U;
      ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
    case 3:
      h ^= static_cast<uint64_t>(data8[2]) << 16U;
      ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
    case 2:
      h ^= static_cast<uint64_t>(data8[1]) << 8U;
      ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
    case 1:
      h ^= static_cast<uint64_t>(data8[0]);
      h *= m;
      ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
    default:
      break;
  }

  h ^= h >> r;

  // not doing the final step here, because this will be done by keyToIdx anyways
  // h *= m;
  // h ^= h >> r;
  return static_cast<size_t>(h);
}

inline size_t hash_int(uint64_t x) noexcept {
  // tried lots of different hashes, let's stick with murmurhash3. It's simple, fast, well tested,