Merge pull request TheHPXProject#6897 from guptapratykshh/concurrent-data-structures

Implement concurrent data structures for Issue TheHPXProject#2235

Author: hkaiser

cmake/HPX_AddConfigTest.cmake

@@ -695,6 +695,24 @@ function(hpx_check_for_mm_prefetch)
   )
 endfunction()
 
+# ##############################################################################
+function(hpx_check_for_cxx23_std_unordered_transparent_erase)
+  add_hpx_config_test(
+    HPX_WITH_CXX23_STD_UNORDERED_TRANSPARENT_ERASE
+    SOURCE cmake/tests/cxx23_std_unordered_transparent_erase.cpp
+    FILE ${ARGN}
+  )
+endfunction()
+
+# ##############################################################################
+function(hpx_check_for_cxx26_std_unordered_transparent_lookup)
+  add_hpx_config_test(
+    HPX_WITH_CXX26_STD_UNORDERED_TRANSPARENT_LOOKUP
+    SOURCE cmake/tests/cxx26_std_unordered_transparent_lookup.cpp
+    FILE ${ARGN}
+  )
+endfunction()
+
 # ##############################################################################
 function(hpx_check_for_stable_inplace_merge)
   add_hpx_config_test(

cmake/HPX_PerformCxxFeatureTests.cmake

@@ -171,6 +171,14 @@ function(hpx_perform_cxx_feature_tests)
     DEFINITIONS HPX_HAVE_CXX_LAMBDA_CAPTURE_DECLTYPE
   )
 
+  hpx_check_for_cxx23_std_unordered_transparent_erase(
+    DEFINITIONS HPX_HAVE_CXX23_STD_UNORDERED_TRANSPARENT_ERASE
+  )
+
+  hpx_check_for_cxx26_std_unordered_transparent_lookup(
+    DEFINITIONS HPX_HAVE_CXX26_STD_UNORDERED_TRANSPARENT_LOOKUP
+  )
+
   hpx_check_for_builtin_forward_move(DEFINITIONS HPX_HAVE_BUILTIN_FORWARD_MOVE)
 
   hpx_check_for_builtin_frame_address(

cmake/tests/cxx23_std_unordered_transparent_erase.cpp

@@ -0,0 +1,54 @@
+//  Copyright (c) 2026 Pratyksh Gupta
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+struct transparent_hash
+{
+    using is_transparent = void;
+    std::size_t operator()(std::string_view sv) const
+    {
+        return std::hash<std::string_view>{}(sv);
+    }
+    std::size_t operator()(std::string const& s) const
+    {
+        return std::hash<std::string>{}(s);
+    }
+};
+
+struct transparent_equal
+{
+    using is_transparent = void;
+    bool operator()(std::string_view sv, std::string const& s) const
+    {
+        return sv == s;
+    }
+    bool operator()(std::string const& s, std::string_view sv) const
+    {
+        return s == sv;
+    }
+    bool operator()(std::string const& s1, std::string const& s2) const
+    {
+        return s1 == s2;
+    }
+};
+
+int main()
+{
+    std::unordered_map<std::string, int, transparent_hash, transparent_equal> m;
+    m["hello"] = 1;
+
+    // Test erase with transparent key (C++23)
+    m.erase(std::string_view("hello"));
+
+    if (!m.empty())
+        return 1;
+
+    return 0;
+}

cmake/tests/cxx26_std_unordered_transparent_lookup.cpp

@@ -0,0 +1,55 @@
+//  Copyright (c) 2026 Pratyksh Gupta
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+struct transparent_hash
+{
+    using is_transparent = void;
+    std::size_t operator()(std::string_view sv) const
+    {
+        return std::hash<std::string_view>{}(sv);
+    }
+    std::size_t operator()(std::string const& s) const
+    {
+        return std::hash<std::string>{}(s);
+    }
+};
+
+struct transparent_equal
+{
+    using is_transparent = void;
+    bool operator()(std::string_view sv, std::string const& s) const
+    {
+        return sv == s;
+    }
+    bool operator()(std::string const& s, std::string_view sv) const
+    {
+        return s == sv;
+    }
+    bool operator()(std::string const& s1, std::string const& s2) const
+    {
+        return s1 == s2;
+    }
+};
+
+int main()
+{
+    std::unordered_map<std::string, int, transparent_hash, transparent_equal> m;
+    m["hello"] = 1;
+
+    // Test operator[] with transparent key (C++26)
+    m[std::string_view("hello")] = 42;
+
+    // Test at() with transparent key (C++26)
+    if (m.at(std::string_view("hello")) != 42)
+        return 1;
+
+    return 0;
+}

libs/core/concurrency/CMakeLists.txt

@@ -10,8 +10,13 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 set(concurrency_headers
     hpx/concurrency/barrier.hpp
     hpx/concurrency/cache_line_data.hpp
+    hpx/concurrency/concurrent_queue.hpp
+    hpx/concurrency/concurrent_unordered_map.hpp
+    hpx/concurrency/concurrent_unordered_set.hpp
+    hpx/concurrency/concurrent_vector.hpp
     hpx/concurrency/concurrentqueue.hpp
     hpx/concurrency/deque.hpp
+    hpx/concurrency/detail/concurrent_accessor.hpp
     hpx/concurrency/detail/contiguous_index_queue.hpp
     hpx/concurrency/detail/copy_payload.hpp
     hpx/concurrency/detail/freelist.hpp

libs/core/concurrency/include/hpx/concurrency/concurrent_queue.hpp

@@ -0,0 +1,19 @@
+//  Copyright (c) 2026 Pratyksh Gupta
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <hpx/config.hpp>
+#include <hpx/concurrency/queue.hpp>
+
+#include <memory>
+
+namespace hpx::concurrent {
+
+    template <typename T, typename Allocator = std::allocator<T>>
+    using concurrent_queue = hpx::lockfree::queue<T, Allocator>;
+
+}    // namespace hpx::concurrent