/src/WasmEdge/lib/common/hash.cpp

Source
#include "common/hash.h"
#include "common/endian.h"

namespace {

inline uint64_t mulMod(uint64_t A, uint64_t B, uint64_t M) noexcept {
  uint64_t R = 0;
  while (B) {
    if (B & 1) {
      uint64_t R2 = R + A;
      if (R2 < R) {
        R2 -= M;
      }
      R = R2 % M;
    }
    B >>= 1;
    if (B) {
      uint64_t A2 = A + A;
      if (A2 < A) {
        A2 -= M;
      }
      A = A2 % M;
    }
  }
  return R;
}

inline uint64_t powMod(uint64_t A, uint64_t B, uint64_t M) noexcept {
  uint64_t R = 1;
  while (B) {
    if (B & 1) {
      R = mulMod(R, A, M);
    }
    B >>= 1;
    if (B) {
      A = mulMod(A, A, M);
    }
  }
  return R;
}

inline bool sprp(uint64_t N, uint64_t A) noexcept {
  uint64_t D = N - 1;
  uint8_t S = 0;
  while (!(D & 0xff)) {
    D >>= 8;
    S += 8;
  }
  if (!(D & 0xf)) {
    D >>= 4;
    S += 4;
  }
  if (!(D & 0x3)) {
    D >>= 2;
    S += 2;
  }
  if (!(D & 0x1)) {
    D >>= 1;
    S += 1;
  }
  uint64_t B = powMod(A, D, N);
  if ((B == 1) || (B == (N - 1))) {
    return true;
  }
  uint8_t R;
  for (R = 1; R < S; R++) {
    B = mulMod(B, B, N);
    if (B <= 1) {
      return false;
    }
    if (B == (N - 1)) {
      return true;
    }
  }
  return false;
}

inline bool isPrime(uint64_t N) noexcept {
  if (N < 2 || !(N & 1)) {
    return false;
  }
  if (N < 4) {
    return true;
  }
  if (!sprp(N, 2)) {
    return false;
  }
  if (N < 2047) {
    return true;
  }
  if (!sprp(N, 3)) {
    return false;
  }
  if (!sprp(N, 5)) {
    return false;
  }
  if (!sprp(N, 7)) {
    return false;
  }
  if (!sprp(N, 11)) {
    return false;
  }
  if (!sprp(N, 13)) {
    return false;
  }
  if (!sprp(N, 17)) {
    return false;
  }
  if (!sprp(N, 19)) {
    return false;
  }
  if (!sprp(N, 23)) {
    return false;
  }
  if (!sprp(N, 29)) {
    return false;
  }
  if (!sprp(N, 31)) {
    return false;
  }
  if (!sprp(N, 37)) {
    return false;
  }
  return true;
}

inline int popcount(uint64_t X) noexcept {
#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
  return __builtin_popcountll(X);
#elif defined(_MSC_VER) && defined(_WIN64)
#if defined(_M_X64)
  return static_cast<int>(_mm_popcnt_u64(X));
#else
  return static_cast<int>(_CountOneBits64(X));
#endif
#else
  X -= (X >> 1) & 0x5555555555555555;
  X = (X & 0x3333333333333333) + ((X >> 2) & 0x3333333333333333);
  X = (X + (X >> 4)) & 0x0f0f0f0f0f0f0f0f;
  X = (X * 0x0101010101010101) >> 56;
  return static_cast<int>(X);
#endif
}

std::array<uint64_t, 4> generate() noexcept {
  std::array<uint64_t, 4> Secret;
  const std::array<uint8_t, 70> C = {
      0x0f, 0x17, 0x1b, 0x1d, 0x1e, 0x27, 0x2b, 0x2d, 0x2e, 0x33, 0x35, 0x36,
      0x39, 0x3a, 0x3c, 0x47, 0x4b, 0x4d, 0x4e, 0x53, 0x55, 0x56, 0x59, 0x5a,
      0x5c, 0x63, 0x65, 0x66, 0x69, 0x6a, 0x6c, 0x71, 0x72, 0x74, 0x78, 0x87,
      0x8b, 0x8d, 0x8e, 0x93, 0x95, 0x96, 0x99, 0x9a, 0x9c, 0xa3, 0xa5, 0xa6,
      0xa9, 0xaa, 0xac, 0xb1, 0xb2, 0xb4, 0xb8, 0xc3, 0xc5, 0xc6, 0xc9, 0xca,
      0xcc, 0xd1, 0xd2, 0xd4, 0xd8, 0xe1, 0xe2, 0xe4, 0xe8, 0xf0};
  std::uniform_int_distribution<uint64_t> Dist(
      UINT64_C(0), static_cast<uint64_t>(C.size() - 1));
  for (size_t I = 0; I < 4; I++) {
    bool Ok;
    do {
      Ok = true;
      Secret[I] = 0;
      for (size_t J = 0; J < 64; J += 8) {
        Secret[I] |= static_cast<uint64_t>(C[Dist(WasmEdge::Hash::RandEngine)])
                     << J;
      }
      if (Secret[I] % 2 == 0) {
        Ok = false;
        continue;
      }
      for (size_t J = 0; J < I; J++) {
        if (popcount(Secret[J] ^ Secret[I]) != 32) {
          Ok = false;
          break;
        }
      }
      if (Ok && !isPrime(Secret[I]))
        Ok = false;
    } while (!Ok);
  }
  return Secret;
}

inline uint64_t read(WasmEdge::Span<const std::byte, 8> Data) noexcept {
  uint64_t V;
  std::memcpy(&V, Data.data(), 8);
  if constexpr (WasmEdge::Endian::native == WasmEdge::Endian::little) {
    return V;
  } else {
    return WasmEdge::byteswap(V);
  }
}
inline uint64_t read(WasmEdge::Span<const std::byte, 4> Data) noexcept {
  uint32_t V;
  std::memcpy(&V, Data.data(), 4);
  if constexpr (WasmEdge::Endian::native == WasmEdge::Endian::little) {
    return V;
  } else {
    return WasmEdge::byteswap(V);
  }
}

inline uint64_t read_small(WasmEdge::Span<const std::byte> Data) noexcept {
  return (static_cast<uint64_t>(Data[0]) << 56) |
         (static_cast<uint64_t>(Data[Data.size() >> 1]) << 32) |
         static_cast<uint64_t>(Data[Data.size() - 1]);
}

static const std::array<uint64_t, 4> Secret = generate();

} // namespace

namespace WasmEdge::Hash {

WASMEDGE_EXPORT uint64_t Hash::rapidHash(Span<const std::byte> Data) noexcept {
  const auto Size = Data.size();
  uint64_t Seed = Secret[3];
  Seed ^= rapidMix(Seed ^ Secret[0], Secret[1]) ^ Size;
  uint64_t A, B;
  if (likely(Data.size() <= 16)) {
    if (likely(Data.size() >= 4)) {
      A = (read(Data.first<4>()) << 32) | read(Data.last<4>());
      const uint64_t delta = ((Data.size() & 24) >> (Data.size() >> 3));
      B = (read(Data.subspan(delta).first<4>()) << 32) |
          read(Data.last(4 + delta).first<4>());
    } else if (likely(Data.size() > 0)) {
      A = read_small(Data);
      B = 0;
    } else {
      A = B = 0;
    }
  } else {
    if (unlikely(Data.size() > 48)) {
      uint64_t See1 = Seed, See2 = Seed;
      while (likely(Data.size() >= 96)) {
        Seed = rapidMix(read(Data.first<8>()) ^ Secret[0],
                        read(Data.subspan<8>().first<8>()) ^ Seed);
        See1 = rapidMix(read(Data.subspan<16>().first<8>()) ^ Secret[1],
                        read(Data.subspan<24>().first<8>()) ^ See1);
        See2 = rapidMix(read(Data.subspan<32>().first<8>()) ^ Secret[2],
                        read(Data.subspan<40>().first<8>()) ^ See2);
        Seed = rapidMix(read(Data.subspan<48>().first<8>()) ^ Secret[0],
                        read(Data.subspan<56>().first<8>()) ^ Seed);
        See1 = rapidMix(read(Data.subspan<64>().first<8>()) ^ Secret[1],
                        read(Data.subspan<72>().first<8>()) ^ See1);
        See2 = rapidMix(read(Data.subspan<80>().first<8>()) ^ Secret[2],
                        read(Data.subspan<88>().first<8>()) ^ See2);
        Data = Data.subspan<96>();
      }
      if (unlikely(Data.size() >= 48)) {
        Seed = rapidMix(read(Data.first<8>()) ^ Secret[0],
                        read(Data.subspan<8>().first<8>()) ^ Seed);
        See1 = rapidMix(read(Data.subspan<16>().first<8>()) ^ Secret[1],
                        read(Data.subspan<24>().first<8>()) ^ See1);
        See2 = rapidMix(read(Data.subspan<32>().first<8>()) ^ Secret[2],
                        read(Data.subspan<40>().first<8>()) ^ See2);
        Data = Data.subspan<48>();
      }

      Seed ^= See1 ^ See2;
    }
    if (Data.size() > 16) {
      Seed = rapidMix(read(Data.first<8>()) ^ Secret[2],
                      read(Data.subspan<8>().first<8>()) ^ Seed ^ Secret[1]);
      if (Data.size() > 32)
        Seed = rapidMix(read(Data.subspan<16>().first<8>()) ^ Secret[2],
                        read(Data.subspan<24>().first<8>()) ^ Seed);
    }
    A = read(Data.last<16>().first<8>());
    B = read(Data.last<8>());
  }
  A ^= Secret[1];
  B ^= Seed;
  rapidMum(A, B);
  return rapidMix(A ^ Secret[0] ^ Size, B ^ Secret[1]);
}

} // namespace WasmEdge::Hash

Coverage Report

Created: 2025-09-27 06:27

Line	Count	Source
1		#include "common/hash.h"
2		#include "common/endian.h"
3
4		namespace {
5
6	54.2k	inline uint64_t mulMod(uint64_t A, uint64_t B, uint64_t M) noexcept {
7	54.2k	uint64_t R = 0;
8	3.16M	while (B) {
9	3.11M	if (B & 1) {
10	1.55M	uint64_t R2 = R + A;
11	1.55M	if (R2 < R) {
12	153k	R2 -= M;
13	153k	}
14	1.55M	R = R2 % M;
15	1.55M	}
16	3.11M	B >>= 1;
17	3.11M	if (B) {
18	3.06M	uint64_t A2 = A + A;
19	3.06M	if (A2 < A) {
20	470k	A2 -= M;
21	470k	}
22	3.06M	A = A2 % M;
23	3.06M	}
24	3.11M	}
25	54.2k	return R;
26	54.2k	}
27
28	588	inline uint64_t powMod(uint64_t A, uint64_t B, uint64_t M) noexcept {
29	588	uint64_t R = 1;
30	36.6k	while (B) {
31	36.0k	if (B & 1) {
32	18.2k	R = mulMod(R, A, M);
33	18.2k	}
34	36.0k	B >>= 1;
35	36.0k	if (B) {
36	35.4k	A = mulMod(A, A, M);
37	35.4k	}
38	36.0k	}
39	588	return R;
40	588	}
41
42	588	inline bool sprp(uint64_t N, uint64_t A) noexcept {
43	588	uint64_t D = N - 1;
44	588	uint8_t S = 0;
45	588	while (!(D & 0xff)) {
46	0	D >>= 8;
47	0	S += 8;
48	0	}
49	588	if (!(D & 0xf)) {
50	59	D >>= 4;
51	59	S += 4;
52	59	}
53	588	if (!(D & 0x3)) {
54	284	D >>= 2;
55	284	S += 2;
56	284	}
57	588	if (!(D & 0x1)) {
58	380	D >>= 1;
59	380	S += 1;
60	380	}
61	588	uint64_t B = powMod(A, D, N);
62	588	if ((B == 1) \|\| (B == (N - 1))) {
63	106	return true;
64	106	}
65	482	uint8_t R;
66	915	for (R = 1; R < S; R++) {
67	519	B = mulMod(B, B, N);
68	519	if (B <= 1) {
69	0	return false;
70	0	}
71	519	if (B == (N - 1)) {
72	86	return true;
73	86	}
74	519	}
75	396	return false;
76	482	}
77
78	412	inline bool isPrime(uint64_t N) noexcept {
79	412	if (N < 2 \|\| !(N & 1)) {
80	0	return false;
81	0	}
82	412	if (N < 4) {
83	0	return true;
84	0	}
85	412	if (!sprp(N, 2)) {
86	396	return false;
87	396	}
88	16	if (N < 2047) {
89	0	return true;
90	0	}
91	16	if (!sprp(N, 3)) {
92	0	return false;
93	0	}
94	16	if (!sprp(N, 5)) {
95	0	return false;
96	0	}
97	16	if (!sprp(N, 7)) {
98	0	return false;
99	0	}
100	16	if (!sprp(N, 11)) {
101	0	return false;
102	0	}
103	16	if (!sprp(N, 13)) {
104	0	return false;
105	0	}
106	16	if (!sprp(N, 17)) {
107	0	return false;
108	0	}
109	16	if (!sprp(N, 19)) {
110	0	return false;
111	0	}
112	16	if (!sprp(N, 23)) {
113	0	return false;
114	0	}
115	16	if (!sprp(N, 29)) {
116	0	return false;
117	0	}
118	16	if (!sprp(N, 31)) {
119	0	return false;
120	0	}
121	16	if (!sprp(N, 37)) {
122	0	return false;
123	0	}
124	16	return true;
125	16	}
126
127	35.8k	inline int popcount(uint64_t X) noexcept {
128	35.8k	#if defined(__GNUC__) \|\| defined(__INTEL_COMPILER) \|\| defined(__clang__)
129	35.8k	return __builtin_popcountll(X);
130		#elif defined(_MSC_VER) && defined(_WIN64)
131		#if defined(_M_X64)
132		return static_cast<int>(_mm_popcnt_u64(X));
133		#else
134		return static_cast<int>(_CountOneBits64(X));
135		#endif
136		#else
137		X -= (X >> 1) & 0x5555555555555555;
138		X = (X & 0x3333333333333333) + ((X >> 2) & 0x3333333333333333);
139		X = (X + (X >> 4)) & 0x0f0f0f0f0f0f0f0f;
140		X = (X * 0x0101010101010101) >> 56;
141		return static_cast<int>(X);
142		#endif
143	35.8k	}
144
145	4	std::array<uint64_t, 4> generate() noexcept {
146	4	std::array<uint64_t, 4> Secret;
147	4	const std::array<uint8_t, 70> C = {
148	4	0x0f, 0x17, 0x1b, 0x1d, 0x1e, 0x27, 0x2b, 0x2d, 0x2e, 0x33, 0x35, 0x36,
149	4	0x39, 0x3a, 0x3c, 0x47, 0x4b, 0x4d, 0x4e, 0x53, 0x55, 0x56, 0x59, 0x5a,
150	4	0x5c, 0x63, 0x65, 0x66, 0x69, 0x6a, 0x6c, 0x71, 0x72, 0x74, 0x78, 0x87,
151	4	0x8b, 0x8d, 0x8e, 0x93, 0x95, 0x96, 0x99, 0x9a, 0x9c, 0xa3, 0xa5, 0xa6,
152	4	0xa9, 0xaa, 0xac, 0xb1, 0xb2, 0xb4, 0xb8, 0xc3, 0xc5, 0xc6, 0xc9, 0xca,
153	4	0xcc, 0xd1, 0xd2, 0xd4, 0xd8, 0xe1, 0xe2, 0xe4, 0xe8, 0xf0};
154	4	std::uniform_int_distribution<uint64_t> Dist(
155	4	UINT64_C(0), static_cast<uint64_t>(C.size() - 1));
156	20	for (size_t I = 0; I < 4; I++) {
157	16	bool Ok;
158	59.7k	do {
159	59.7k	Ok = true;
160	59.7k	Secret[I] = 0;
161	538k	for (size_t J = 0; J < 64; J += 8) {
162	478k	Secret[I] \|= static_cast<uint64_t>(C[Dist(WasmEdge::Hash::RandEngine)])
163	478k	<< J;
164	478k	}
165	59.7k	if (Secret[I] % 2 == 0) {
166	29.9k	Ok = false;
167	29.9k	continue;
168	29.9k	}
169	36.2k	for (size_t J = 0; J < I; J++) {
170	35.8k	if (popcount(Secret[J] ^ Secret[I]) != 32) {
171	29.4k	Ok = false;
172	29.4k	break;
173	29.4k	}
174	35.8k	}
175	29.8k	if (Ok && !isPrime(Secret[I]))
176	396	Ok = false;
177	59.7k	} while (!Ok);
178	16	}
179	4	return Secret;
180	4	}
181
182	3.49M	inline uint64_t read(WasmEdge::Span<const std::byte, 8> Data) noexcept {
183	3.49M	uint64_t V;
184	3.49M	std::memcpy(&V, Data.data(), 8);
185	3.49M	if constexpr (WasmEdge::Endian::native == WasmEdge::Endian::little) {
186	3.49M	return V;
187		} else {
188		return WasmEdge::byteswap(V);
189		}
190	3.49M	}
191	375k	inline uint64_t read(WasmEdge::Span<const std::byte, 4> Data) noexcept {
192	375k	uint32_t V;
193	375k	std::memcpy(&V, Data.data(), 4);
194	375k	if constexpr (WasmEdge::Endian::native == WasmEdge::Endian::little) {
195	375k	return V;
196		} else {
197		return WasmEdge::byteswap(V);
198		}
199	375k	}
200
201	1.40M	inline uint64_t read_small(WasmEdge::Span<const std::byte> Data) noexcept {
202	1.40M	return (static_cast<uint64_t>(Data[0]) << 56) \|
203	1.40M	(static_cast<uint64_t>(Data[Data.size() >> 1]) << 32) \|
204	1.40M	static_cast<uint64_t>(Data[Data.size() - 1]);
205	1.40M	}
206
207		static const std::array<uint64_t, 4> Secret = generate();
208
209		} // namespace
210
211		namespace WasmEdge::Hash {
212
213	1.52M	WASMEDGE_EXPORT uint64_t Hash::rapidHash(Span<const std::byte> Data) noexcept {
214	1.52M	const auto Size = Data.size();
215	1.52M	uint64_t Seed = Secret[3];
216	1.52M	Seed ^= rapidMix(Seed ^ Secret[0], Secret[1]) ^ Size;
217	1.52M	uint64_t A, B;
218	1.52M	if (likely(Data.size() <= 16)) {
219	1.49M	if (likely(Data.size() >= 4)) {
220	93.8k	A = (read(Data.first<4>()) << 32) \| read(Data.last<4>());
221	93.8k	const uint64_t delta = ((Data.size() & 24) >> (Data.size() >> 3));
222	93.8k	B = (read(Data.subspan(delta).first<4>()) << 32) \|
223	93.8k	read(Data.last(4 + delta).first<4>());
224	1.40M	} else if (likely(Data.size() > 0)) {
225	1.40M	A = read_small(Data);
226	1.40M	B = 0;
227	1.40M	} else {
228	57	A = B = 0;
229	57	}
230	1.49M	} else {
231	27.6k	if (unlikely(Data.size() > 48)) {
232	290	uint64_t See1 = Seed, See2 = Seed;
233	282k	while (likely(Data.size() >= 96)) {
234	281k	Seed = rapidMix(read(Data.first<8>()) ^ Secret[0],
235	281k	read(Data.subspan<8>().first<8>()) ^ Seed);
236	281k	See1 = rapidMix(read(Data.subspan<16>().first<8>()) ^ Secret[1],
237	281k	read(Data.subspan<24>().first<8>()) ^ See1);
238	281k	See2 = rapidMix(read(Data.subspan<32>().first<8>()) ^ Secret[2],
239	281k	read(Data.subspan<40>().first<8>()) ^ See2);
240	281k	Seed = rapidMix(read(Data.subspan<48>().first<8>()) ^ Secret[0],
241	281k	read(Data.subspan<56>().first<8>()) ^ Seed);
242	281k	See1 = rapidMix(read(Data.subspan<64>().first<8>()) ^ Secret[1],
243	281k	read(Data.subspan<72>().first<8>()) ^ See1);
244	281k	See2 = rapidMix(read(Data.subspan<80>().first<8>()) ^ Secret[2],
245	281k	read(Data.subspan<88>().first<8>()) ^ See2);
246	281k	Data = Data.subspan<96>();
247	281k	}
248	290	if (unlikely(Data.size() >= 48)) {
249	131	Seed = rapidMix(read(Data.first<8>()) ^ Secret[0],
250	131	read(Data.subspan<8>().first<8>()) ^ Seed);
251	131	See1 = rapidMix(read(Data.subspan<16>().first<8>()) ^ Secret[1],
252	131	read(Data.subspan<24>().first<8>()) ^ See1);
253	131	See2 = rapidMix(read(Data.subspan<32>().first<8>()) ^ Secret[2],
254	131	read(Data.subspan<40>().first<8>()) ^ See2);
255	131	Data = Data.subspan<48>();
256	131	}
257
258	290	Seed ^= See1 ^ See2;
259	290	}
260	27.6k	if (Data.size() > 16) {
261	27.4k	Seed = rapidMix(read(Data.first<8>()) ^ Secret[2],
262	27.4k	read(Data.subspan<8>().first<8>()) ^ Seed ^ Secret[1]);
263	27.4k	if (Data.size() > 32)
264	2.14k	Seed = rapidMix(read(Data.subspan<16>().first<8>()) ^ Secret[2],
265	2.14k	read(Data.subspan<24>().first<8>()) ^ Seed);
266	27.4k	}
267	27.6k	A = read(Data.last<16>().first<8>());
268	27.6k	B = read(Data.last<8>());
269	27.6k	}
270	1.52M	A ^= Secret[1];
271	1.52M	B ^= Seed;
272	1.52M	rapidMum(A, B);
273	1.52M	return rapidMix(A ^ Secret[0] ^ Size, B ^ Secret[1]);
274	1.52M	}
275
276		} // namespace WasmEdge::Hash