Skip to content

Commit cbe692d

Browse files
author
Julian LALU
committed
Improve hashmap
1 parent c4c7bc6 commit cbe692d

7 files changed

Lines changed: 121 additions & 121 deletions

File tree

‎interface/core/bits/bits_common.h‎

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ namespace hud::common
1616
return integral;
1717
}
1818

19-
/** Determines if a 64-bit word contains any zero byte using a SIMD-like technique
19+
/** Determines if a 64-bit word contains any zero byte using a SIMD-like technique
2020
* Example:
2121
* value = 0x1213140015001617
2222
* result = 0x0000008000800000
@@ -54,30 +54,30 @@ namespace hud::common
5454
// }
5555

5656
/** Returns the number of consecutive 0 bits in the value. */
57-
[[nodiscard]] static constexpr u32 leading_zero(u8 value) noexcept
57+
[[nodiscard]] static constexpr u32 leading_zeros(u8 value) noexcept
5858
{
59-
return leading_zero(u16 {value}) - 8;
59+
return leading_zeros(u16 {value}) - 8;
6060
}
6161

6262
/** Returns the number of consecutive 0 bits in the value. */
63-
[[nodiscard]] static constexpr u32 leading_zero(u16 value) noexcept
63+
[[nodiscard]] static constexpr u32 leading_zeros(u16 value) noexcept
6464
{
65-
return leading_zero(u32 {value}) - 16;
65+
return leading_zeros(u32 {value}) - 16;
6666
}
6767

6868
/** Returns the number of consecutive 0 bits in the value. */
69-
[[nodiscard]] static constexpr u32 leading_zero(u32 value) noexcept
69+
[[nodiscard]] static constexpr u32 leading_zeros(u32 value) noexcept
7070
{
7171
return value == 0 ? 32 : 31 - hud::math::floor_log2(u32(value));
7272
}
7373

7474
/** Returns the number of consecutive 0 bits in the value. */
75-
[[nodiscard]] static constexpr u32 leading_zero(u64 value) noexcept
75+
[[nodiscard]] static constexpr u32 leading_zeros(u64 value) noexcept
7676
{
7777
return value == 0 ? 64 : 63 - hud::math::floor_log2(value);
7878
}
7979

80-
[[nodiscard]] static constexpr u32 trailing_zero(u8 value) noexcept
80+
[[nodiscard]] static constexpr u32 trailing_zeros(u8 value) noexcept
8181
{
8282
u8 c = 8; // c will be the number of zero bits on the right
8383
value &= -i8(value);
@@ -92,7 +92,7 @@ namespace hud::common
9292
return c;
9393
}
9494

95-
[[nodiscard]] static constexpr u32 trailing_zero(u16 value) noexcept
95+
[[nodiscard]] static constexpr u32 trailing_zeros(u16 value) noexcept
9696
{
9797
u16 c = 16; // c will be the number of zero bits on the right
9898
value &= -i16(value);
@@ -109,7 +109,7 @@ namespace hud::common
109109
return c;
110110
}
111111

112-
[[nodiscard]] static constexpr u32 trailing_zero(u32 value) noexcept
112+
[[nodiscard]] static constexpr u32 trailing_zeros(u32 value) noexcept
113113
{
114114
u32 c = 32; // c will be the number of zero bits on the right
115115
value &= -i32(value);
@@ -128,7 +128,7 @@ namespace hud::common
128128
return c;
129129
}
130130

131-
[[nodiscard]] static constexpr u64 trailing_zero(u64 value) noexcept
131+
[[nodiscard]] static constexpr u64 trailing_zeros(u64 value) noexcept
132132
{
133133
u64 c = 64; // c will be the number of zero bits on the right
134134
value &= -i64(value);

‎interface/core/bits/bits_linux.h‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -107,66 +107,66 @@ namespace hud::linux
107107
}
108108

109109
/** Returns the number of consecutive 0 bits in the value. */
110-
[[nodiscard]] static constexpr u32 leading_zero(u8 value) noexcept
110+
[[nodiscard]] static constexpr u32 leading_zeros(u8 value) noexcept
111111
{
112-
return leading_zero(u32 {value}) - 24;
112+
return leading_zeros(u32 {value}) - 24;
113113
}
114114

115115
/** Returns the number of consecutive 0 bits in the value. */
116-
[[nodiscard]] static constexpr u32 leading_zero(u16 value) noexcept
116+
[[nodiscard]] static constexpr u32 leading_zeros(u16 value) noexcept
117117
{
118118
#if HD_HAS_BUILTIN_CLZS
119119
return value == 0 ? 16 : __builtin_clzs(value);
120120
#else
121-
return hud::common::bits::leading_zero(value);
121+
return hud::common::bits::leading_zeros(value);
122122
#endif
123123
}
124124

125125
/** Returns the number of consecutive 0 bits in the value. */
126-
[[nodiscard]] static constexpr u32 leading_zero(u32 value) noexcept
126+
[[nodiscard]] static constexpr u32 leading_zeros(u32 value) noexcept
127127
{
128128
#if HD_HAS_BUILTIN_CLZ
129129
return value == 0 ? 32 : __builtin_clz(value);
130130
#else
131-
return hud::common::bits::leading_zero(value);
131+
return hud::common::bits::leading_zeros(value);
132132
#endif
133133
}
134134

135135
/** Returns the number of consecutive 0 bits in the value. */
136-
[[nodiscard]] static constexpr u32 leading_zero(u64 value) noexcept
136+
[[nodiscard]] static constexpr u32 leading_zeros(u64 value) noexcept
137137
{
138138
#if HD_HAS_BUILTIN_CLZLL
139139
return value == 0 ? 64 : __builtin_clzll(value);
140140
#else
141-
return hud::common::bits::leading_zero(value);
141+
return hud::common::bits::leading_zeros(value);
142142
#endif
143143
};
144144

145-
[[nodiscard]] static constexpr u32 trailing_zero(u8 value) noexcept
145+
[[nodiscard]] static constexpr u32 trailing_zeros(u8 value) noexcept
146146
{
147-
return value == 0 ? 8 : trailing_zero(u32 {value});
147+
return value == 0 ? 8 : trailing_zeros(u32 {value});
148148
}
149149

150-
[[nodiscard]] static constexpr u32 trailing_zero(u16 value) noexcept
150+
[[nodiscard]] static constexpr u32 trailing_zeros(u16 value) noexcept
151151
{
152-
return value == 0 ? 16 : trailing_zero(u32 {value});
152+
return value == 0 ? 16 : trailing_zeros(u32 {value});
153153
}
154154

155-
[[nodiscard]] static constexpr u32 trailing_zero(u32 value) noexcept
155+
[[nodiscard]] static constexpr u32 trailing_zeros(u32 value) noexcept
156156
{
157157
#if HD_HAS_BUILTIN_CTZ
158158
return value == 0 ? 32 : __builtin_ctz(value);
159159
#else
160-
return value == 0 ? 32 : hud::common::bits::trailing_zero(value);
160+
return value == 0 ? 32 : hud::common::bits::trailing_zeros(value);
161161
#endif
162162
}
163163

164-
[[nodiscard]] static constexpr u64 trailing_zero(u64 value) noexcept
164+
[[nodiscard]] static constexpr u64 trailing_zeros(u64 value) noexcept
165165
{
166166
#if HD_HAS_BUILTIN_CTZLL
167167
return value == 0 ? 64 : __builtin_ctzll(value);
168168
#else
169-
return value == 0 ? 64 : hud::common::bits::trailing_zero(value);
169+
return value == 0 ? 64 : hud::common::bits::trailing_zeros(value);
170170
#endif
171171
}
172172
};

‎interface/core/bits/bits_windows.h‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -139,31 +139,31 @@ namespace hud::windows
139139
}
140140

141141
/** Returns the number of consecutive 0 bits in the value. */
142-
[[nodiscard]] static constexpr u32 leading_zero(u8 value) noexcept
142+
[[nodiscard]] static constexpr u32 leading_zeros(u8 value) noexcept
143143
{
144-
return leading_zero(u32 {value}) - 24;
144+
return leading_zeros(u32 {value}) - 24;
145145
}
146146

147147
/** Returns the number of consecutive 0 bits in the value. */
148-
[[nodiscard]] static constexpr u32 leading_zero(u16 value) noexcept
148+
[[nodiscard]] static constexpr u32 leading_zeros(u16 value) noexcept
149149
{
150150
#if HD_HAS_BUILTIN_CLZS
151151
return value == 0 ? 16 : __builtin_clzs(value);
152152
#else
153-
return leading_zero(u32 {value}) - 16;
153+
return leading_zeros(u32 {value}) - 16;
154154
#endif
155155
}
156156

157157
/** Returns the number of consecutive 0 bits in the value. */
158-
[[nodiscard]] static constexpr u32 leading_zero(u32 value) noexcept
158+
[[nodiscard]] static constexpr u32 leading_zeros(u32 value) noexcept
159159
{
160160
#if HD_HAS_BUILTIN_CLZ
161161
return value == 0 ? 32 : __builtin_clz(value);
162162
#else
163163
if (value == 0)
164164
return 32;
165165
if (hud::is_constant_evaluated())
166-
return hud::common::bits::leading_zero(value);
166+
return hud::common::bits::leading_zeros(value);
167167
u32 result = 0;
168168
if (_BitScanReverse((unsigned long *)&result, value))
169169
{
@@ -174,15 +174,15 @@ namespace hud::windows
174174
}
175175

176176
/** Returns the number of consecutive 0 bits in the value. */
177-
[[nodiscard]] static constexpr u32 leading_zero(u64 value) noexcept
177+
[[nodiscard]] static constexpr u32 leading_zeros(u64 value) noexcept
178178
{
179179
#if HD_HAS_BUILTIN_CLZLL
180180
return value == 0 ? 64 : __builtin_clzll(value);
181181
#else
182182
if (value == 0)
183183
return 64;
184184
if (hud::is_constant_evaluated())
185-
return hud::common::bits::leading_zero(value);
185+
return hud::common::bits::leading_zeros(value);
186186
#if defined(HD_TARGET_X64)
187187
u32 result = 0;
188188
if (_BitScanReverse64((unsigned long *)&result, value))
@@ -205,40 +205,40 @@ namespace hud::windows
205205
#endif
206206
}
207207

208-
[[nodiscard]] static constexpr u32 trailing_zero(u8 value) noexcept
208+
[[nodiscard]] static constexpr u32 trailing_zeros(u8 value) noexcept
209209
{
210-
return value == 0 ? 8 : trailing_zero(u32 {value});
210+
return value == 0 ? 8 : trailing_zeros(u32 {value});
211211
}
212212

213-
[[nodiscard]] static constexpr u32 trailing_zero(u16 value) noexcept
213+
[[nodiscard]] static constexpr u32 trailing_zeros(u16 value) noexcept
214214
{
215-
return value == 0 ? 16 : trailing_zero(u32 {value});
215+
return value == 0 ? 16 : trailing_zeros(u32 {value});
216216
}
217217

218-
[[nodiscard]] static constexpr u32 trailing_zero(u32 value) noexcept
218+
[[nodiscard]] static constexpr u32 trailing_zeros(u32 value) noexcept
219219
{
220220
#if HD_HAS_BUILTIN_CTZ
221221
return value == 0 ? 32 : __builtin_ctz(value);
222222
#else
223223
if (value == 0)
224224
return 32;
225225
if (hud::is_constant_evaluated())
226-
return hud::common::bits::trailing_zero(value);
226+
return hud::common::bits::trailing_zeros(value);
227227
u32 result = 0;
228228
_BitScanForward((unsigned long *)&result, value);
229229
return result;
230230
#endif
231231
}
232232

233-
[[nodiscard]] static constexpr u64 trailing_zero(u64 value) noexcept
233+
[[nodiscard]] static constexpr u64 trailing_zeros(u64 value) noexcept
234234
{
235235
#if HD_HAS_BUILTIN_CTZLL
236236
return value == 0 ? 64 : __builtin_ctzll(value);
237237
#else
238238
if (value == 0)
239239
return 64;
240240
if (hud::is_constant_evaluated())
241-
return hud::common::bits::trailing_zero(value);
241+
return hud::common::bits::trailing_zeros(value);
242242
#if defined(HD_TARGET_X64)
243243
u64 result = 0;
244244
_BitScanForward64((unsigned long *)&result, value);

‎interface/core/containers/hashset.h‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -367,7 +367,7 @@ namespace hud
367367
[[nodiscard]] constexpr u32 first_non_null_index() const noexcept
368368
{
369369
// Get number of trailing zero and divide it by 8 (>>3) to get the insert offset of the byte
370-
return hud::bits::trailing_zero(mask_value_) >> 3;
370+
return hud::bits::trailing_zeros(mask_value_) >> 3;
371371
}
372372

373373
[[nodiscard]]
@@ -409,12 +409,12 @@ namespace hud
409409

410410
[[nodiscard]] constexpr u32 trailing_zeros() const noexcept
411411
{
412-
return hud::bits::trailing_zero(mask_value_) >> 3;
412+
return hud::bits::trailing_zeros(mask_value_) >> 3;
413413
}
414414

415415
[[nodiscard]] constexpr u32 leading_zeros() const noexcept
416416
{
417-
return hud::bits::leading_zero(mask_value_) >> 3;
417+
return hud::bits::leading_zeros(mask_value_) >> 3;
418418
}
419419
};
420420

@@ -549,7 +549,7 @@ namespace hud
549549
// ctrl | ~(ctrl >> 7) will have the lowest bit set to zero for kEmpty and
550550
// kDeleted. We lower all other bits and count number of trailing zeros.
551551
constexpr uint64_t bits {0x0101010101010101ULL};
552-
return static_cast<u32>(hud::bits::trailing_zero((value_ | ~(value_ >> 7)) & bits) >> 3);
552+
return static_cast<u32>(hud::bits::trailing_zeros((value_ | ~(value_ >> 7)) & bits) >> 3);
553553
// return static_cast<u32>(countr_zero((ctrl | ~(ctrl >> 7)) & bits) >> 3);
554554
// return 0;
555555
}

‎interface/core/i128/i128_portable.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1004,12 +1004,12 @@ namespace hud
10041004
{
10051005
hud::check(hi != 0);
10061006
HD_ASSUME(hi != 0);
1007-
return 127 - hud::bits::leading_zero(hi);
1007+
return 127 - hud::bits::leading_zeros(hi);
10081008
}
10091009
const u64 low = n.low_;
10101010
hud::check(low != 0);
10111011
HD_ASSUME(low != 0);
1012-
return 63 - hud::bits::leading_zero(low);
1012+
return 63 - hud::bits::leading_zeros(low);
10131013
};
10141014

10151015
// Left aligns the MSB of the denominator and the dividend.

‎test/bits/bits_leading_zero.cpp‎

Lines changed: 36 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -2,52 +2,52 @@
22

33
GTEST_TEST(bits, leading_zero_u8)
44
{
5-
hud_assert_eq(hud::bits::leading_zero(u8(0)), 8);
6-
hud_assert_eq(hud::bits::leading_zero(u8(1)), 7);
7-
hud_assert_eq(hud::bits::leading_zero(u8(2)), 6);
8-
hud_assert_eq(hud::bits::leading_zero(u8(0xFF)), 0);
9-
hud_assert_eq(hud::bits::leading_zero(u8(0x80)), 0);
10-
hud_assert_eq(hud::bits::leading_zero(u8(0x40)), 1);
11-
hud_assert_eq(hud::bits::leading_zero(u8(0x0F)), 4);
12-
hud_assert_eq(hud::bits::leading_zero(u8(0x10)), 3);
5+
hud_assert_eq(hud::bits::leading_zeros(u8(0)), 8);
6+
hud_assert_eq(hud::bits::leading_zeros(u8(1)), 7);
7+
hud_assert_eq(hud::bits::leading_zeros(u8(2)), 6);
8+
hud_assert_eq(hud::bits::leading_zeros(u8(0xFF)), 0);
9+
hud_assert_eq(hud::bits::leading_zeros(u8(0x80)), 0);
10+
hud_assert_eq(hud::bits::leading_zeros(u8(0x40)), 1);
11+
hud_assert_eq(hud::bits::leading_zeros(u8(0x0F)), 4);
12+
hud_assert_eq(hud::bits::leading_zeros(u8(0x10)), 3);
1313
}
1414

1515
GTEST_TEST(bits, leading_zero_u16)
1616
{
17-
hud_assert_eq(hud::bits::leading_zero(u16(0)), 16);
18-
hud_assert_eq(hud::bits::leading_zero(u16(1)), 15);
19-
hud_assert_eq(hud::bits::leading_zero(u16(2)), 14);
20-
hud_assert_eq(hud::bits::leading_zero(u16(0xFFFF)), 0);
21-
hud_assert_eq(hud::bits::leading_zero(u16(0x8000)), 0);
22-
hud_assert_eq(hud::bits::leading_zero(u16(0x4000)), 1);
23-
hud_assert_eq(hud::bits::leading_zero(u16(0x0F00)), 4);
24-
hud_assert_eq(hud::bits::leading_zero(u16(0x1000)), 3);
17+
hud_assert_eq(hud::bits::leading_zeros(u16(0)), 16);
18+
hud_assert_eq(hud::bits::leading_zeros(u16(1)), 15);
19+
hud_assert_eq(hud::bits::leading_zeros(u16(2)), 14);
20+
hud_assert_eq(hud::bits::leading_zeros(u16(0xFFFF)), 0);
21+
hud_assert_eq(hud::bits::leading_zeros(u16(0x8000)), 0);
22+
hud_assert_eq(hud::bits::leading_zeros(u16(0x4000)), 1);
23+
hud_assert_eq(hud::bits::leading_zeros(u16(0x0F00)), 4);
24+
hud_assert_eq(hud::bits::leading_zeros(u16(0x1000)), 3);
2525
}
2626

2727
GTEST_TEST(bits, leading_zero_u32)
2828
{
29-
hud_assert_eq(hud::bits::leading_zero(u32(0)), 32);
30-
hud_assert_eq(hud::bits::leading_zero(u32(1)), 31);
31-
hud_assert_eq(hud::bits::leading_zero(u32(2)), 30);
32-
hud_assert_eq(hud::bits::leading_zero(u32(0xFFFFFFFF)), 0);
33-
hud_assert_eq(hud::bits::leading_zero(u32(0x80000000)), 0);
34-
hud_assert_eq(hud::bits::leading_zero(u32(0x40000000)), 1);
35-
hud_assert_eq(hud::bits::leading_zero(u32(0x0F000000)), 4);
36-
hud_assert_eq(hud::bits::leading_zero(u32(0x10000000)), 3);
29+
hud_assert_eq(hud::bits::leading_zeros(u32(0)), 32);
30+
hud_assert_eq(hud::bits::leading_zeros(u32(1)), 31);
31+
hud_assert_eq(hud::bits::leading_zeros(u32(2)), 30);
32+
hud_assert_eq(hud::bits::leading_zeros(u32(0xFFFFFFFF)), 0);
33+
hud_assert_eq(hud::bits::leading_zeros(u32(0x80000000)), 0);
34+
hud_assert_eq(hud::bits::leading_zeros(u32(0x40000000)), 1);
35+
hud_assert_eq(hud::bits::leading_zeros(u32(0x0F000000)), 4);
36+
hud_assert_eq(hud::bits::leading_zeros(u32(0x10000000)), 3);
3737
}
3838

3939
GTEST_TEST(bits, leading_zero_u64)
4040
{
41-
hud_assert_eq(hud::bits::leading_zero(u64(0)), 64);
42-
hud_assert_eq(hud::bits::leading_zero(u64(1)), 63);
43-
hud_assert_eq(hud::bits::leading_zero(u64(2)), 62);
44-
hud_assert_eq(hud::bits::leading_zero(u64(0xFFFFFFFFFFFFFFFF)), 0);
45-
hud_assert_eq(hud::bits::leading_zero(u64(0x8000000000000000)), 0);
46-
hud_assert_eq(hud::bits::leading_zero(u64(0x4000000000000000)), 1);
47-
hud_assert_eq(hud::bits::leading_zero(u64(0x00000000FFFFFFFF)), 32);
48-
hud_assert_eq(hud::bits::leading_zero(u64(0x0000FFFF00000000)), 16);
49-
hud_assert_eq(hud::bits::leading_zero(u64(0x00F0000000000000)), 8);
50-
hud_assert_eq(hud::bits::leading_zero(u64(0x0F00000000000000)), 4);
51-
hud_assert_eq(hud::bits::leading_zero(u64(0x1000000000000000)), 3);
52-
hud_assert_eq(hud::bits::leading_zero(u64(0x2000000000000000)), 2);
41+
hud_assert_eq(hud::bits::leading_zeros(u64(0)), 64);
42+
hud_assert_eq(hud::bits::leading_zeros(u64(1)), 63);
43+
hud_assert_eq(hud::bits::leading_zeros(u64(2)), 62);
44+
hud_assert_eq(hud::bits::leading_zeros(u64(0xFFFFFFFFFFFFFFFF)), 0);
45+
hud_assert_eq(hud::bits::leading_zeros(u64(0x8000000000000000)), 0);
46+
hud_assert_eq(hud::bits::leading_zeros(u64(0x4000000000000000)), 1);
47+
hud_assert_eq(hud::bits::leading_zeros(u64(0x00000000FFFFFFFF)), 32);
48+
hud_assert_eq(hud::bits::leading_zeros(u64(0x0000FFFF00000000)), 16);
49+
hud_assert_eq(hud::bits::leading_zeros(u64(0x00F0000000000000)), 8);
50+
hud_assert_eq(hud::bits::leading_zeros(u64(0x0F00000000000000)), 4);
51+
hud_assert_eq(hud::bits::leading_zeros(u64(0x1000000000000000)), 3);
52+
hud_assert_eq(hud::bits::leading_zeros(u64(0x2000000000000000)), 2);
5353
}

0 commit comments

Comments
 (0)