Skip to content

[WIP] Robin Hood Hashing #818

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
aterenin wants to merge 18 commits into
base: dev
Choose a base branch
from
Open

[WIP] Robin Hood Hashing #818

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
18 commits
Select commit Hold shift + click to select a range
db77ced
Add initial templates for Robin Hood probing.
aterenin Jun 2, 2026
d177546
Add Robin Hood probe distance test.
aterenin Jun 2, 2026
75a78df
Add Robin Hood get methods.
aterenin Jun 2, 2026
dc90ebe
Add Robin Hood invariant test.
aterenin Jun 2, 2026
12b8e57
Add non-CG insert for Robin Hood.
aterenin Jun 3, 2026
0cc3fbd
Add CG insert for Robin Hood.
aterenin Jun 3, 2026
2a92131
Propagate Robin Hood insert to variants.
aterenin Jun 3, 2026
c27f483
Add initial tests and fix insert_or_assign for Robin Hood.
aterenin Jun 4, 2026
d2341e5
Add Robin Hood erase and tests.
aterenin Jun 5, 2026
1f3d64e
[pre-commit.ci] auto code formatting
pre-commit-ci[bot] Jun 5, 2026
f26495a
Disallow 96-bit slots for Robin Hood.
aterenin Jun 6, 2026
826eb84
Revert to original version.
aterenin Jun 24, 2026
10af0f9
Copy baseline implementation.
aterenin Jun 25, 2026
1fb7cf3
Add Robin Hood get and insert.
aterenin Jun 25, 2026
53c884c
[pre-commit.ci] auto code formatting
pre-commit-ci[bot] Jun 25, 2026
d4cff56
Merge branch 'NVIDIA:dev' into dev
aterenin Jun 25, 2026
7c4cd12
Adapt tests and comment expected failures.
aterenin Jun 29, 2026
d7c8fed
[pre-commit.ci] auto code formatting
pre-commit-ci[bot] Jun 29, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2,378 changes: 2,378 additions & 0 deletions include/cuco/detail/open_addressing/robin_hood/open_addressing_ref_impl.cuh
View file
Open in desktop

Large diffs are not rendered by default.

8 changes: 7 additions & 1 deletion include/cuco/static_map_ref.cuh
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,7 @@
#pragma once

#include <cuco/detail/open_addressing/open_addressing_ref_impl.cuh>
#include <cuco/detail/open_addressing/robin_hood/open_addressing_ref_impl.cuh>
#include <cuco/hash_functions.cuh>
#include <cuco/operator.hpp>
#include <cuco/probing_scheme.cuh>
Expand Down Expand Up @@ -74,7 +75,12 @@ class static_map_ref
static constexpr auto allows_duplicates = false;

/// Implementation type
using impl_type = detail::
//
// HARD-WIRE (experimental Robin Hood PR): static_map is routed through the Robin Hood engine
// instead of the generic open-addressing engine. This single line is what makes static_map use
// Robin Hood probing; downstream front-end work replaces it with a proper backend-selection
// mechanism. See robin_hood_refactor_plan.md.
using impl_type = detail::robin_hood::
open_addressing_ref_impl<Key, Scope, KeyEqual, ProbingScheme, StorageRef, allows_duplicates>;

public:
Expand Down
3 changes: 2 additions & 1 deletion tests/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -93,7 +93,8 @@ ConfigureTest(STATIC_MAP_TEST
static_map/stream_test.cu
static_map/rehash_test.cu
static_map/retrieve_test.cu
static_map/retrieve_if_test.cu)
static_map/retrieve_if_test.cu
static_map/robin_hood_test.cu)

###################################################################################################
# - dynamic_map tests -----------------------------------------------------------------------------
Expand Down
24 changes: 14 additions & 10 deletions tests/static_map/contains_test.cu
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -124,19 +124,23 @@ TEMPLATE_TEST_CASE_SIG(
Value,
Probe,
CGSize),
(int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
(int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
// Robin Hood is linear-probing + single-CAS only. Unsupported variants are kept commented for
// reference / easy re-enable: double_hashing (no RH probe_distance), padded >8B slots
// (int32/int64, int64/int32), and >16B slots. 16B packable slots (int64/int64) need 128-bit
// atomics, so they sit under the #if.
// (int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
// (int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 2)
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 2)
#if defined(CUCO_HAS_128BIT_ATOMICS)
,
(__int128_t, __int128_t, cuco::test::probe_sequence::double_hashing, 2),
(__int128_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, __int128_t, cuco::test::probe_sequence::linear_probing, 2)
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 2)
// (__int128_t, __int128_t, cuco::test::probe_sequence::double_hashing, 2),
// (__int128_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, __int128_t, cuco::test::probe_sequence::linear_probing, 2)
#endif
)
{
Expand Down
40 changes: 22 additions & 18 deletions tests/static_map/duplicate_keys_test.cu
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -38,27 +38,31 @@ TEMPLATE_TEST_CASE_SIG(
Value,
Probe,
CGSize),
(int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
(int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
(int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
(int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
// Robin Hood is linear-probing + single-CAS only. Unsupported variants are kept commented for
// reference / easy re-enable: double_hashing (no RH probe_distance), padded >8B slots
// (int32/int64, int64/int32), and >16B slots. 16B packable slots (int64/int64) need 128-bit
// atomics, so they sit under the #if.
// (int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
// (int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
// (int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
// (int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
// (int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
(int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 2),
(int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 2)
// (int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 2)
// (int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 2),
// (int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
// (int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
#if defined(CUCO_HAS_128BIT_ATOMICS)
,
(__int128_t, __int128_t, cuco::test::probe_sequence::double_hashing, 2),
(__int128_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, __int128_t, cuco::test::probe_sequence::linear_probing, 2)
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 2)
// (__int128_t, __int128_t, cuco::test::probe_sequence::double_hashing, 2),
// (__int128_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, __int128_t, cuco::test::probe_sequence::linear_probing, 2)
#endif
)
{
Expand Down
40 changes: 22 additions & 18 deletions tests/static_map/erase_test.cu
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -87,27 +87,31 @@ TEMPLATE_TEST_CASE_SIG(
Value,
Probe,
CGSize),
(int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
(int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
(int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
(int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
// Robin Hood is linear-probing + single-CAS only. Unsupported variants are kept commented for
// reference / easy re-enable: double_hashing (no RH probe_distance), padded >8B slots
// (int32/int64, int64/int32), and >16B slots. 16B packable slots (int64/int64) need 128-bit
// atomics, so they sit under the #if.
// (int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
// (int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
// (int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
// (int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
// (int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
(int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 2),
(int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 2)
// (int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 2)
// (int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 2),
// (int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
// (int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
#if defined(CUCO_HAS_128BIT_ATOMICS)
,
(__int128_t, __int128_t, cuco::test::probe_sequence::double_hashing, 2),
(__int128_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, __int128_t, cuco::test::probe_sequence::linear_probing, 2)
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 2)
// (__int128_t, __int128_t, cuco::test::probe_sequence::double_hashing, 2),
// (__int128_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, __int128_t, cuco::test::probe_sequence::linear_probing, 2)
#endif
)
{
Expand Down
50 changes: 27 additions & 23 deletions tests/static_map/find_test.cu
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -138,37 +138,41 @@ TEMPLATE_TEST_CASE_SIG(
Value,
Probe,
CGSize),
(int8_t, int8_t, cuco::test::probe_sequence::double_hashing, 1),
(int8_t, int8_t, cuco::test::probe_sequence::double_hashing, 2),
(int8_t, int16_t, cuco::test::probe_sequence::double_hashing, 2),
(int16_t, int16_t, cuco::test::probe_sequence::double_hashing, 1),
(int16_t, int16_t, cuco::test::probe_sequence::double_hashing, 2),
(int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
(int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
(int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
(int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
// Robin Hood is linear-probing + single-CAS only. Unsupported variants are kept commented for
// reference / easy re-enable: double_hashing (no RH probe_distance), padded >8B slots
// (int32/int64, int64/int32), and >16B slots. 16B packable slots (int64/int64) need 128-bit
// atomics, so they sit under the #if.
// (int8_t, int8_t, cuco::test::probe_sequence::double_hashing, 1),
// (int8_t, int8_t, cuco::test::probe_sequence::double_hashing, 2),
// (int8_t, int16_t, cuco::test::probe_sequence::double_hashing, 2),
// (int16_t, int16_t, cuco::test::probe_sequence::double_hashing, 1),
// (int16_t, int16_t, cuco::test::probe_sequence::double_hashing, 2),
// (int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
// (int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
// (int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
// (int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
// (int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
(int8_t, int8_t, cuco::test::probe_sequence::linear_probing, 1),
(int8_t, int8_t, cuco::test::probe_sequence::linear_probing, 2),
(int8_t, int16_t, cuco::test::probe_sequence::linear_probing, 2),
(int16_t, int16_t, cuco::test::probe_sequence::linear_probing, 1),
(int16_t, int16_t, cuco::test::probe_sequence::linear_probing, 2),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
(int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 2),
(int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 2)
// (int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 2)
// (int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 2),
// (int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
// (int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
#if defined(CUCO_HAS_128BIT_ATOMICS)
,
(__int128_t, __int128_t, cuco::test::probe_sequence::double_hashing, 2),
(__int128_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, __int128_t, cuco::test::probe_sequence::linear_probing, 2)
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 2)
// (__int128_t, __int128_t, cuco::test::probe_sequence::double_hashing, 2),
// (__int128_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, __int128_t, cuco::test::probe_sequence::linear_probing, 2)
#endif
)
{
Expand Down
38 changes: 20 additions & 18 deletions tests/static_map/for_each_test.cu
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -85,28 +85,30 @@ TEMPLATE_TEST_CASE_SIG(
Value,
Probe,
CGSize),
(int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
(int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
(int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
(int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
// Robin Hood is linear-probing + single-CAS only; unsupported variants (double_hashing,
// padded/oversized slots) are commented; 16B int64/int64 needs 128-bit atomics.
// (int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int32_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
// (int32_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
// (int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 1),
// (int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
// (int64_t, int32_t, cuco::test::probe_sequence::double_hashing, 2),
// (int64_t, int64_t, cuco::test::probe_sequence::double_hashing, 2),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
(int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 2),
(int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 2),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 2)
// (int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 1), // padded 12B slot
(int32_t, int32_t, cuco::test::probe_sequence::linear_probing, 2)
// (int32_t, int64_t, cuco::test::probe_sequence::linear_probing, 2), // padded 12B slot
// (int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 1), // padded 12B slot
// (int64_t, int32_t, cuco::test::probe_sequence::linear_probing, 2), // padded 12B slot
#if defined(CUCO_HAS_128BIT_ATOMICS)
,
(__int128_t, __int128_t, cuco::test::probe_sequence::double_hashing, 2),
(__int128_t, int64_t, cuco::test::probe_sequence::double_hashing, 1),
(int32_t, __int128_t, cuco::test::probe_sequence::linear_probing, 2)
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 1),
(int64_t, int64_t, cuco::test::probe_sequence::linear_probing, 2)
#endif
// (__int128_t, __int128_t, cuco::test::probe_sequence::double_hashing, 2), // 32B slot
// (__int128_t, int64_t, cuco::test::probe_sequence::double_hashing, 1), // oversized slot
// (int32_t, __int128_t, cuco::test::probe_sequence::linear_probing, 2) // oversized slot
)
{
constexpr size_type num_keys{100};
Expand Down
10 changes: 6 additions & 4 deletions tests/static_map/hash_test.cu
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,7 +31,7 @@ using size_type = std::size_t;
template <typename Key, typename Hash>
void test_hash_function()
{
using Value = int64_t;
using Value = Key;

constexpr size_type num_keys{400};

Expand Down Expand Up @@ -63,15 +63,17 @@ void test_hash_function()
REQUIRE(cuco::test::all_of(d_keys_exist.begin(), d_keys_exist.end(), cuda::std::identity{}));
}

// Robin Hood is linear-probing + single-CAS only; unsupported variants (double_hashing,
// padded/oversized slots) are commented; 16B int64/int64 needs 128-bit atomics.
TEMPLATE_TEST_CASE_SIG("static_map hash tests",
"",
((typename Key)),
(int32_t),
(int64_t)
(int32_t)
#if defined(CUCO_HAS_128BIT_ATOMICS)
,
(__int128_t)
(int64_t)
#endif
// (__int128_t) // 32B slot: oversized for single-CAS Robin Hood
)
{
test_hash_function<Key, cuco::murmurhash3_32<Key>>();
Expand Down
Loading