From f8d92b09381ce5d18a64f1908465fe99e94d5a1f Mon Sep 17 00:00:00 2001
From: Hartmut Kaiser <hartmut.kaiser@gmail.com>
Date: Wed, 11 Sep 2024 17:52:46 -0500
Subject: [PATCH] Resolve circular dependency between concurrency and
 allocator_support modules

---
 .../thread_local_caching_allocator.hpp        | 16 ++++---
 libs/core/async_base/CMakeLists.txt           |  4 +-
 .../include/hpx/async_base/dataflow.hpp       |  9 ++--
 libs/core/async_combinators/CMakeLists.txt    |  3 +-
 .../hpx/async_combinators/when_all.hpp        | 10 ++--
 .../include/hpx/concurrency/stack.hpp         |  8 +++-
 libs/core/concurrency/tests/unit/stack.cpp    |  8 ++--
 libs/core/execution/CMakeLists.txt            |  3 +-
 .../hpx/execution/detail/future_exec.hpp      |  9 ++--
 libs/core/executors/CMakeLists.txt            |  3 +-
 .../hpx/executors/parallel_executor.hpp       |  9 ++--
 libs/core/futures/CMakeLists.txt              |  3 +-
 .../futures/include/hpx/futures/future.hpp    | 37 ++++++++------
 .../include/hpx/futures/futures_factory.hpp   |  7 ++-
 .../hpx/futures/packaged_continuation.hpp     | 12 +++--
 libs/core/lcos_local/CMakeLists.txt           |  3 +-
 .../include/hpx/lcos_local/and_gate.hpp       |  7 ++-
 libs/full/async_distributed/CMakeLists.txt    |  2 +-
 .../detail/async_implementations.hpp          | 48 ++++++++++---------
 19 files changed, 122 insertions(+), 79 deletions(-)

diff --git a/libs/core/allocator_support/include/hpx/allocator_support/thread_local_caching_allocator.hpp b/libs/core/allocator_support/include/hpx/allocator_support/thread_local_caching_allocator.hpp
index 1dec447e3041..0afd89a7c3fe 100644
--- a/libs/core/allocator_support/include/hpx/allocator_support/thread_local_caching_allocator.hpp
+++ b/libs/core/allocator_support/include/hpx/allocator_support/thread_local_caching_allocator.hpp
@@ -1,4 +1,4 @@
-//  Copyright (c) 2023 Hartmut Kaiser
+//  Copyright (c) 2023-2024 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,7 +8,6 @@
 
 #include <hpx/config.hpp>
 #include <hpx/allocator_support/config/defines.hpp>
-#include <hpx/concurrency/stack.hpp>
 
 #include <cstddef>
 #include <memory>
@@ -21,8 +20,10 @@ namespace hpx::util {
 #if defined(HPX_ALLOCATOR_SUPPORT_HAVE_CACHING) &&                             \
     !((defined(HPX_HAVE_CUDA) && defined(__CUDACC__)) ||                       \
         defined(HPX_HAVE_HIP))
+
     ///////////////////////////////////////////////////////////////////////////
-    template <typename T = char, typename Allocator = std::allocator<T>>
+    template <template <typename, typename> class Stack, typename T = char,
+        typename Allocator = std::allocator<T>>
     struct thread_local_caching_allocator
     {
         HPX_NO_UNIQUE_ADDRESS Allocator alloc;
@@ -38,7 +39,7 @@ namespace hpx::util {
         template <typename U>
         struct rebind
         {
-            using other = thread_local_caching_allocator<U,
+            using other = thread_local_caching_allocator<Stack, U,
                 typename traits::template rebind_alloc<U>>;
         };
 
@@ -113,7 +114,7 @@ namespace hpx::util {
             }
 
             HPX_NO_UNIQUE_ADDRESS Allocator alloc;
-            hpx::lockfree::stack<std::pair<T*, size_type>> data;
+            Stack<std::pair<T*, size_type>, Allocator> data;
             std::size_t allocated = 0;
             std::size_t deallocated = 0;
         };
@@ -134,7 +135,7 @@ namespace hpx::util {
 
         template <typename U, typename Alloc>
         explicit thread_local_caching_allocator(
-            thread_local_caching_allocator<U, Alloc> const&
+            thread_local_caching_allocator<Stack, U, Alloc> const&
                 rhs) noexcept(noexcept(std::
                 is_nothrow_copy_constructible_v<Alloc>))
           : alloc(rhs.alloc)
@@ -198,7 +199,8 @@ namespace hpx::util {
         }
     };
 #else
-    template <typename T = char, typename Allocator = std::allocator<T>>
+    template <template <typename, typename> class Stack, typename T = char,
+        typename Allocator = std::allocator<T>>
     using thread_local_caching_allocator = Allocator;
 #endif
 }    // namespace hpx::util
diff --git a/libs/core/async_base/CMakeLists.txt b/libs/core/async_base/CMakeLists.txt
index acd6ff32e0de..6a18a9e12b7a 100644
--- a/libs/core/async_base/CMakeLists.txt
+++ b/libs/core/async_base/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2022 The STE||AR-Group
+# Copyright (c) 2020-2024 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -34,6 +34,6 @@ add_hpx_module(
   COMPAT_HEADERS ${async_base_compat_headers}
   SOURCES ${async_base_sources}
   MODULE_DEPENDENCIES hpx_allocator_support hpx_concepts hpx_config
-                      hpx_coroutines hpx_tag_invoke
+                      hpx_concurrency hpx_coroutines hpx_tag_invoke
   CMAKE_SUBDIRS examples tests
 )
diff --git a/libs/core/async_base/include/hpx/async_base/dataflow.hpp b/libs/core/async_base/include/hpx/async_base/dataflow.hpp
index 6015ab1b6091..a6a3bb790bdf 100644
--- a/libs/core/async_base/include/hpx/async_base/dataflow.hpp
+++ b/libs/core/async_base/include/hpx/async_base/dataflow.hpp
@@ -1,4 +1,4 @@
-//  Copyright (c) 2007-2022 Hartmut Kaiser
+//  Copyright (c) 2007-2024 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -29,6 +29,7 @@ namespace hpx {
 #else
 
 #include <hpx/config.hpp>
+#include <hpx/concurrency/stack.hpp>
 #include <hpx/modules/allocator_support.hpp>
 #include <hpx/modules/concepts.hpp>
 #include <hpx/modules/tag_invoke.hpp>
@@ -60,12 +61,14 @@ namespace hpx {
             // clang-format on
             friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
                 dataflow_t tag, F&& f, Ts&&... ts)
-                -> decltype(tag(hpx::util::thread_local_caching_allocator<char,
+                -> decltype(tag(hpx::util::thread_local_caching_allocator<
+                                    hpx::lockfree::variable_size_stack, char,
                                     hpx::util::internal_allocator<>>{},
                     HPX_FORWARD(F, f), HPX_FORWARD(Ts, ts)...))
             {
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::thread_local_caching_allocator<
+                        hpx::lockfree::variable_size_stack, char,
                         hpx::util::internal_allocator<>>;
                 return hpx::functional::tag_invoke(tag, allocator_type{},
                     HPX_FORWARD(F, f), HPX_FORWARD(Ts, ts)...);
diff --git a/libs/core/async_combinators/CMakeLists.txt b/libs/core/async_combinators/CMakeLists.txt
index b7cf2059b489..ff730d928fe7 100644
--- a/libs/core/async_combinators/CMakeLists.txt
+++ b/libs/core/async_combinators/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2023 The STE||AR-Group
+# Copyright (c) 2019-2024 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -43,6 +43,7 @@ add_hpx_module(
   EXCLUDE_FROM_GLOBAL_HEADER "hpx/async_combinators/future_wait.hpp"
   MODULE_DEPENDENCIES
     hpx_async_base
+    hpx_concurrency
     hpx_config
     hpx_errors
     hpx_futures
diff --git a/libs/core/async_combinators/include/hpx/async_combinators/when_all.hpp b/libs/core/async_combinators/include/hpx/async_combinators/when_all.hpp
index 58d425b982d4..3f4d400e5eea 100644
--- a/libs/core/async_combinators/include/hpx/async_combinators/when_all.hpp
+++ b/libs/core/async_combinators/include/hpx/async_combinators/when_all.hpp
@@ -1,4 +1,4 @@
-//  Copyright (c) 2007-2022 Hartmut Kaiser
+//  Copyright (c) 2007-2024 Hartmut Kaiser
 //  Copyright (c) 2013 Agustin Berge
 //  Copyright (c) 2017 Denis Blank
 //
@@ -131,6 +131,7 @@ namespace hpx {
 #include <hpx/config.hpp>
 #include <hpx/allocator_support/internal_allocator.hpp>
 #include <hpx/allocator_support/thread_local_caching_allocator.hpp>
+#include <hpx/concurrency/stack.hpp>
 #include <hpx/datastructures/tuple.hpp>
 #include <hpx/functional/tag_invoke.hpp>
 #include <hpx/futures/detail/future_data.hpp>
@@ -201,14 +202,16 @@ namespace hpx::lcos::detail {
             return async_visit_future(HPX_FORWARD(T, current));
         }
 
+        // clang-format off
         template <typename T, typename N>
         auto operator()(hpx::util::async_traverse_detach_tag, T&& current,
             N&& next) -> decltype(async_detach_future(HPX_FORWARD(T, current),
-            HPX_FORWARD(N, next)))
+                          HPX_FORWARD(N, next)))
         {
             return async_detach_future(
                 HPX_FORWARD(T, current), HPX_FORWARD(N, next));
         }
+        // clang-format on
 
         template <typename T>
         void operator()(hpx::util::async_traverse_complete_tag, T&& pack)
@@ -226,7 +229,8 @@ namespace hpx::lcos::detail {
         using frame_type = async_when_all_frame<result_type>;
         using no_addref = typename frame_type::base_type::init_no_addref;
 
-        using allocator_type = hpx::util::thread_local_caching_allocator<char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<
+            hpx::lockfree::variable_size_stack, char,
             hpx::util::internal_allocator<>>;
         auto frame = hpx::util::traverse_pack_async_allocator(allocator_type{},
             hpx::util::async_traverse_in_place_tag<frame_type>{}, no_addref{},
diff --git a/libs/core/concurrency/include/hpx/concurrency/stack.hpp b/libs/core/concurrency/include/hpx/concurrency/stack.hpp
index ffeb832a40dc..b80922e6e434 100644
--- a/libs/core/concurrency/include/hpx/concurrency/stack.hpp
+++ b/libs/core/concurrency/include/hpx/concurrency/stack.hpp
@@ -1,5 +1,5 @@
 //  Copyright (C) 2008-2013 Tim Blechmann
-//  Copyright (c) 2022-2023 Hartmut Kaiser
+//  Copyright (c) 2022-2024 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -770,4 +770,10 @@ namespace hpx::lockfree {
 
         pool_t pool;
     };
+
+    template <typename T, typename Allocator = std::allocator<T>>
+    class variable_size_stack : public stack<T, Allocator>
+    {
+        using stack<T, Allocator>::stack;
+    };
 }    // namespace hpx::lockfree
diff --git a/libs/core/concurrency/tests/unit/stack.cpp b/libs/core/concurrency/tests/unit/stack.cpp
index cd15bb0b581f..f080a049738a 100644
--- a/libs/core/concurrency/tests/unit/stack.cpp
+++ b/libs/core/concurrency/tests/unit/stack.cpp
@@ -73,7 +73,7 @@ void ranged_unsynchronized_push_test()
     HPX_TEST(!stk.unsynchronized_pop(out));
 }
 
-void fixed_size_stack_test()
+void variable_size_stack_test()
 {
     hpx::lockfree::stack<long, std::allocator<long>, 128> stk;
 
@@ -89,7 +89,7 @@ void fixed_size_stack_test()
     HPX_TEST(stk.empty());
 }
 
-void fixed_size_stack_test_exhausted()
+void variable_size_stack_test_exhausted()
 {
     hpx::lockfree::stack<long, std::allocator<long>, 2> stk;
 
@@ -206,8 +206,8 @@ int main()
     unsafe_stack_test();
     ranged_push_test();
     ranged_unsynchronized_push_test();
-    fixed_size_stack_test();
-    fixed_size_stack_test_exhausted();
+    variable_size_stack_test();
+    variable_size_stack_test_exhausted();
     bounded_stack_test_exhausted();
     stack_consume_one_test();
     stack_consume_all_test();
diff --git a/libs/core/execution/CMakeLists.txt b/libs/core/execution/CMakeLists.txt
index 2f6cde663464..0f36cbc43993 100644
--- a/libs/core/execution/CMakeLists.txt
+++ b/libs/core/execution/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2022 The STE||AR-Group
+# Copyright (c) 2019-2024 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -160,6 +160,7 @@ add_hpx_module(
   MODULE_DEPENDENCIES
     hpx_async_base
     hpx_async_combinators
+    hpx_concurrency
     hpx_config
     hpx_threading
     hpx_pack_traversal
diff --git a/libs/core/execution/include/hpx/execution/detail/future_exec.hpp b/libs/core/execution/include/hpx/execution/detail/future_exec.hpp
index 367bd58f9496..a8d644afe1c0 100644
--- a/libs/core/execution/include/hpx/execution/detail/future_exec.hpp
+++ b/libs/core/execution/include/hpx/execution/detail/future_exec.hpp
@@ -1,4 +1,4 @@
-//  Copyright (c) 2007-2022 Hartmut Kaiser
+//  Copyright (c) 2007-2024 Hartmut Kaiser
 //  Copyright (c) 2013 Agustin Berge
 //
 //  SPDX-License-Identifier: BSL-1.0
@@ -13,6 +13,7 @@
 #include <hpx/assert.hpp>
 #include <hpx/async_base/launch_policy.hpp>
 #include <hpx/async_base/traits/is_launch_policy.hpp>
+#include <hpx/concurrency/stack.hpp>
 #include <hpx/coroutines/thread_enums.hpp>
 #include <hpx/execution/traits/executor_traits.hpp>
 #include <hpx/execution/traits/future_then_result_exec.hpp>
@@ -64,9 +65,9 @@ namespace hpx::lcos::detail {
             using continuation_result_type =
                 hpx::util::invoke_result_t<F, Future>;
 
-            using allocator_type =
-                hpx::util::thread_local_caching_allocator<char,
-                    hpx::util::internal_allocator<>>;
+            using allocator_type = hpx::util::thread_local_caching_allocator<
+                hpx::lockfree::variable_size_stack, char,
+                hpx::util::internal_allocator<>>;
 
             hpx::traits::detail::shared_state_ptr_t<result_type> p =
                 detail::make_continuation_alloc<continuation_result_type>(
diff --git a/libs/core/executors/CMakeLists.txt b/libs/core/executors/CMakeLists.txt
index 1e0c7e5b3a53..43985414eaed 100644
--- a/libs/core/executors/CMakeLists.txt
+++ b/libs/core/executors/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2022 The STE||AR-Group
+# Copyright (c) 2020-2024 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -97,6 +97,7 @@ add_hpx_module(
     hpx_allocator_support
     hpx_async_base
     hpx_concepts
+    hpx_concurrency
     hpx_config
     hpx_errors
     hpx_execution
diff --git a/libs/core/executors/include/hpx/executors/parallel_executor.hpp b/libs/core/executors/include/hpx/executors/parallel_executor.hpp
index abedc6fd341f..915551b7c579 100644
--- a/libs/core/executors/include/hpx/executors/parallel_executor.hpp
+++ b/libs/core/executors/include/hpx/executors/parallel_executor.hpp
@@ -1,5 +1,5 @@
 //  Copyright (c) 2019-2020 ETH Zurich
-//  Copyright (c) 2007-2023 Hartmut Kaiser
+//  Copyright (c) 2007-2024 Hartmut Kaiser
 //  Copyright (c) 2019 Agustin Berge
 //
 //  SPDX-License-Identifier: BSL-1.0
@@ -12,6 +12,7 @@
 #include <hpx/allocator_support/internal_allocator.hpp>
 #include <hpx/allocator_support/thread_local_caching_allocator.hpp>
 #include <hpx/async_base/launch_policy.hpp>
+#include <hpx/concurrency/stack.hpp>
 #include <hpx/execution/detail/async_launch_policy_dispatch.hpp>
 #include <hpx/execution/detail/future_exec.hpp>
 #include <hpx/execution/detail/post_policy_dispatch.hpp>
@@ -389,9 +390,9 @@ namespace hpx::execution {
                 hpx::bind_back(HPX_FORWARD(F, f), HPX_FORWARD(Ts, ts)...));
 #endif
 
-            using allocator_type =
-                hpx::util::thread_local_caching_allocator<char,
-                    hpx::util::internal_allocator<>>;
+            using allocator_type = hpx::util::thread_local_caching_allocator<
+                hpx::lockfree::variable_size_stack, char,
+                hpx::util::internal_allocator<>>;
             hpx::traits::detail::shared_state_ptr_t<result_type> p =
                 lcos::detail::make_continuation_alloc_nounwrap<result_type>(
                     allocator_type{}, HPX_FORWARD(Future, predecessor),
diff --git a/libs/core/futures/CMakeLists.txt b/libs/core/futures/CMakeLists.txt
index 3387538bd92b..bf0bd5c68214 100644
--- a/libs/core/futures/CMakeLists.txt
+++ b/libs/core/futures/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2022 The STE||AR-Group
+# Copyright (c) 2019-2024 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -68,6 +68,7 @@ add_hpx_module(
     hpx_assertion
     hpx_async_base
     hpx_concepts
+    hpx_concurrency
     hpx_config
     hpx_errors
     hpx_functional
diff --git a/libs/core/futures/include/hpx/futures/future.hpp b/libs/core/futures/include/hpx/futures/future.hpp
index 6a1a2ef58b8a..7d83b551b362 100644
--- a/libs/core/futures/include/hpx/futures/future.hpp
+++ b/libs/core/futures/include/hpx/futures/future.hpp
@@ -18,6 +18,7 @@
 #include <hpx/assert.hpp>
 #include <hpx/async_base/launch_policy.hpp>
 #include <hpx/concepts/concepts.hpp>
+#include <hpx/concurrency/stack.hpp>
 #include <hpx/errors/try_catch_exception_ptr.hpp>
 #include <hpx/functional/detail/invoke.hpp>
 #include <hpx/functional/experimental/scope_exit.hpp>
@@ -378,13 +379,14 @@ namespace hpx::lcos::detail {
         template <typename F>
         static auto then(Derived&& fut, F&& f, error_code& ec = throws)
             -> decltype(future_then_dispatch<std::decay_t<F>>::call_alloc(
-                hpx::util::thread_local_caching_allocator<char,
+                hpx::util::thread_local_caching_allocator<
+                    hpx::lockfree::variable_size_stack, char,
                     hpx::util::internal_allocator<>>{},
                 HPX_MOVE(fut), HPX_FORWARD(F, f)))
         {
-            using allocator_type =
-                hpx::util::thread_local_caching_allocator<char,
-                    hpx::util::internal_allocator<>>;
+            using allocator_type = hpx::util::thread_local_caching_allocator<
+                hpx::lockfree::variable_size_stack, char,
+                hpx::util::internal_allocator<>>;
 
             using result_type =
                 decltype(future_then_dispatch<std::decay_t<F>>::call_alloc(
@@ -404,13 +406,14 @@ namespace hpx::lcos::detail {
         template <typename F, typename T0>
         static auto then(Derived&& fut, T0&& t0, F&& f, error_code& ec = throws)
             -> decltype(future_then_dispatch<std::decay_t<T0>>::call_alloc(
-                hpx::util::thread_local_caching_allocator<char,
+                hpx::util::thread_local_caching_allocator<
+                    hpx::lockfree::variable_size_stack, char,
                     hpx::util::internal_allocator<>>{},
                 HPX_MOVE(fut), HPX_FORWARD(T0, t0), HPX_FORWARD(F, f)))
         {
-            using allocator_type =
-                hpx::util::thread_local_caching_allocator<char,
-                    hpx::util::internal_allocator<>>;
+            using allocator_type = hpx::util::thread_local_caching_allocator<
+                hpx::lockfree::variable_size_stack, char,
+                hpx::util::internal_allocator<>>;
 
             using result_type =
                 decltype(future_then_dispatch<std::decay_t<T0>>::call_alloc(
@@ -1246,7 +1249,8 @@ namespace hpx {
         std::is_constructible_v<T, Ts&&...> || std::is_void_v<T>, future<T>>
     make_ready_future(Ts&&... ts)
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<
+            hpx::lockfree::variable_size_stack, char,
             hpx::util::internal_allocator<>>;
         return make_ready_future_alloc<T>(
             allocator_type{}, HPX_FORWARD(Ts, ts)...);
@@ -1270,7 +1274,8 @@ namespace hpx {
     HPX_FORCEINLINE future<hpx::util::decay_unwrap_t<T>> make_ready_future(
         T&& init)
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<
+            hpx::lockfree::variable_size_stack, char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<hpx::util::decay_unwrap_t<T>>(
             allocator_type{}, HPX_FORWARD(T, init));
@@ -1351,7 +1356,8 @@ namespace hpx {
     // extension: create a pre-initialized future object
     HPX_FORCEINLINE future<void> make_ready_future()
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<
+            hpx::lockfree::variable_size_stack, char,
             hpx::util::internal_allocator<>>;
         return make_ready_future_alloc<void>(allocator_type{}, util::unused);
     }
@@ -1593,7 +1599,8 @@ namespace hpx::lcos {
     std::enable_if_t<std::is_constructible_v<T, Ts&&...> || std::is_void_v<T>,
         hpx::future<T>> make_ready_future(Ts&&... ts)
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<
+            hpx::lockfree::variable_size_stack, char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<T>(
             allocator_type{}, HPX_FORWARD(Ts, ts)...);
@@ -1616,7 +1623,8 @@ namespace hpx::lcos {
         "hpx::make_ready_future instead.")
     hpx::future<hpx::util::decay_unwrap_t<T>> make_ready_future(T&& init)
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<
+            hpx::lockfree::variable_size_stack, char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<hpx::util::decay_unwrap_t<T>>(
             allocator_type{}, HPX_FORWARD(T, init));
@@ -1675,7 +1683,8 @@ namespace hpx::lcos {
         "hpx::make_ready_future instead.")
     inline hpx::future<void> make_ready_future()
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<
+            hpx::lockfree::variable_size_stack, char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<void>(
             allocator_type{}, util::unused);
diff --git a/libs/core/futures/include/hpx/futures/futures_factory.hpp b/libs/core/futures/include/hpx/futures/futures_factory.hpp
index ac412045a4ee..3898333e56ee 100644
--- a/libs/core/futures/include/hpx/futures/futures_factory.hpp
+++ b/libs/core/futures/include/hpx/futures/futures_factory.hpp
@@ -12,6 +12,7 @@
 #include <hpx/allocator_support/allocator_deleter.hpp>
 #include <hpx/allocator_support/internal_allocator.hpp>
 #include <hpx/async_base/launch_policy.hpp>
+#include <hpx/concurrency/stack.hpp>
 #include <hpx/coroutines/thread_enums.hpp>
 #include <hpx/errors/try_catch_exception_ptr.hpp>
 #include <hpx/execution_base/execution.hpp>
@@ -770,7 +771,8 @@ namespace hpx::lcos::local {
                 !std::is_same_v<std::decay_t<F>, futures_factory>>>
         explicit futures_factory(F&& f)
           : task_(detail::create_task_object<Result, Cancelable>::call(
-                hpx::util::thread_local_caching_allocator<char,
+                hpx::util::thread_local_caching_allocator<
+                    hpx::lockfree::variable_size_stack, char,
                     hpx::util::internal_allocator<>>{},
                 HPX_FORWARD(F, f)))
         {
@@ -778,7 +780,8 @@ namespace hpx::lcos::local {
 
         explicit futures_factory(Result (*f)())
           : task_(detail::create_task_object<Result, Cancelable>::call(
-                hpx::util::thread_local_caching_allocator<char,
+                hpx::util::thread_local_caching_allocator<
+                    hpx::lockfree::variable_size_stack, char,
                     hpx::util::internal_allocator<>>{},
                 f))
         {
diff --git a/libs/core/futures/include/hpx/futures/packaged_continuation.hpp b/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
index f337114d1d23..204f52bd10e9 100644
--- a/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
+++ b/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
@@ -13,6 +13,7 @@
 #include <hpx/allocator_support/thread_local_caching_allocator.hpp>
 #include <hpx/assert.hpp>
 #include <hpx/async_base/launch_policy.hpp>
+#include <hpx/concurrency/stack.hpp>
 #include <hpx/errors/try_catch_exception_ptr.hpp>
 #include <hpx/futures/detail/future_data.hpp>
 #include <hpx/futures/traits/acquire_shared_state.hpp>
@@ -540,7 +541,7 @@ struct hpx::traits::detail::shared_state_allocator<
 namespace hpx::lcos::detail {
 
     template <typename Allocator, typename Future>
-    inline traits::detail::shared_state_ptr_t<future_unwrap_result_t<Future>>
+    traits::detail::shared_state_ptr_t<future_unwrap_result_t<Future>>
     unwrap_impl_alloc(Allocator const& a, Future&& future, error_code& /*ec*/)
     {
         using base_allocator = Allocator;
@@ -573,17 +574,18 @@ namespace hpx::lcos::detail {
     }
 
     template <typename Allocator, typename Future>
-    inline traits::detail::shared_state_ptr_t<future_unwrap_result_t<Future>>
+    traits::detail::shared_state_ptr_t<future_unwrap_result_t<Future>>
     unwrap_alloc(Allocator const& a, Future&& future, error_code& ec)
     {
         return unwrap_impl_alloc(a, HPX_FORWARD(Future, future), ec);
     }
 
     template <typename Future>
-    inline traits::detail::shared_state_ptr_t<future_unwrap_result_t<Future>>
-    unwrap(Future&& future, error_code& ec)
+    traits::detail::shared_state_ptr_t<future_unwrap_result_t<Future>> unwrap(
+        Future&& future, error_code& ec)
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<
+            hpx::lockfree::variable_size_stack, char,
             hpx::util::internal_allocator<>>;
         return unwrap_impl_alloc(
             allocator_type{}, HPX_FORWARD(Future, future), ec);
diff --git a/libs/core/lcos_local/CMakeLists.txt b/libs/core/lcos_local/CMakeLists.txt
index d4978905a229..b590593d9a31 100644
--- a/libs/core/lcos_local/CMakeLists.txt
+++ b/libs/core/lcos_local/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2023 The STE||AR-Group
+# Copyright (c) 2019-2024 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -48,6 +48,7 @@ add_hpx_module(
   HEADERS ${lcos_local_headers}
   COMPAT_HEADERS ${lcos_local_compat_headers}
   MODULE_DEPENDENCIES
+    hpx_concurrency
     hpx_config
     hpx_execution
     hpx_executors
diff --git a/libs/core/lcos_local/include/hpx/lcos_local/and_gate.hpp b/libs/core/lcos_local/include/hpx/lcos_local/and_gate.hpp
index bf5134ae1a8f..1961bc916147 100644
--- a/libs/core/lcos_local/include/hpx/lcos_local/and_gate.hpp
+++ b/libs/core/lcos_local/include/hpx/lcos_local/and_gate.hpp
@@ -10,6 +10,7 @@
 #include <hpx/allocator_support/internal_allocator.hpp>
 #include <hpx/allocator_support/thread_local_caching_allocator.hpp>
 #include <hpx/assert.hpp>
+#include <hpx/concurrency/stack.hpp>
 #include <hpx/datastructures/detail/dynamic_bitset.hpp>
 #include <hpx/datastructures/detail/intrusive_list.hpp>
 #include <hpx/functional/bind_front.hpp>
@@ -51,7 +52,8 @@ namespace hpx::lcos::local {
         explicit base_and_gate(std::size_t count = 0)
           : received_segments_(count)
           , promise_(std::allocator_arg,
-                hpx::util::thread_local_caching_allocator<char,
+                hpx::util::thread_local_caching_allocator<
+                    hpx::lockfree::variable_size_stack, char,
                     hpx::util::internal_allocator<>>{})
           , generation_(1)
         {
@@ -209,7 +211,8 @@ namespace hpx::lcos::local {
                 {
                     // we have received the last missing segment
                     using allocator_type =
-                        hpx::util::thread_local_caching_allocator<char,
+                        hpx::util::thread_local_caching_allocator<
+                            hpx::lockfree::variable_size_stack, char,
                             hpx::util::internal_allocator<>>;
 
                     hpx::promise<void> p(std::allocator_arg, allocator_type{});
diff --git a/libs/full/async_distributed/CMakeLists.txt b/libs/full/async_distributed/CMakeLists.txt
index 8be2723538a8..3fbfefc16daf 100644
--- a/libs/full/async_distributed/CMakeLists.txt
+++ b/libs/full/async_distributed/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2023 The STE||AR-Group
+# Copyright (c) 2019-2024 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/libs/full/async_distributed/include/hpx/async_distributed/detail/async_implementations.hpp b/libs/full/async_distributed/include/hpx/async_distributed/detail/async_implementations.hpp
index 35a1479f955d..d1fe5b1edce7 100644
--- a/libs/full/async_distributed/include/hpx/async_distributed/detail/async_implementations.hpp
+++ b/libs/full/async_distributed/include/hpx/async_distributed/detail/async_implementations.hpp
@@ -1,4 +1,4 @@
-//  Copyright (c) 2007-2023 Hartmut Kaiser
+//  Copyright (c) 2007-2024 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -17,6 +17,7 @@
 #include <hpx/components_base/pinned_ptr.hpp>
 #include <hpx/components_base/traits/action_decorate_function.hpp>
 #include <hpx/components_base/traits/component_supports_migration.hpp>
+#include <hpx/concurrency/stack.hpp>
 #include <hpx/functional/traits/get_function_address.hpp>
 #include <hpx/functional/traits/get_function_annotation.hpp>
 #include <hpx/futures/future.hpp>
@@ -204,7 +205,8 @@ namespace hpx::detail {
                 handle_managed_target<Result> hmt(id, f);
 
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::thread_local_caching_allocator<
+                        hpx::lockfree::variable_size_stack, char,
                         hpx::util::internal_allocator<>>;
                 lcos::packaged_action<Action, Result> p(
                     std::allocator_arg, allocator_type{});
@@ -232,9 +234,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type =
-                hpx::util::thread_local_caching_allocator<char,
-                    hpx::util::internal_allocator<>>;
+            using allocator_type = hpx::util::thread_local_caching_allocator<
+                hpx::lockfree::variable_size_stack, char,
+                hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -258,9 +260,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type =
-                hpx::util::thread_local_caching_allocator<char,
-                    hpx::util::internal_allocator<>>;
+            using allocator_type = hpx::util::thread_local_caching_allocator<
+                hpx::lockfree::variable_size_stack, char,
+                hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -284,9 +286,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type =
-                hpx::util::thread_local_caching_allocator<char,
-                    hpx::util::internal_allocator<>>;
+            using allocator_type = hpx::util::thread_local_caching_allocator<
+                hpx::lockfree::variable_size_stack, char,
+                hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -548,7 +550,8 @@ namespace hpx::detail {
             if (policy == launch::sync || hpx::detail::has_async_policy(policy))
             {
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::thread_local_caching_allocator<
+                        hpx::lockfree::variable_size_stack, char,
                         hpx::util::internal_allocator<>>;
                 lcos::packaged_action<action_type, result_type> p(
                     std::allocator_arg, allocator_type{});
@@ -562,7 +565,8 @@ namespace hpx::detail {
             else if (policy == launch::deferred)
             {
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::thread_local_caching_allocator<
+                        hpx::lockfree::variable_size_stack, char,
                         hpx::util::internal_allocator<>>;
                 lcos::packaged_action<action_type, result_type> p(
                     std::allocator_arg, allocator_type{});
@@ -630,9 +634,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type =
-                hpx::util::thread_local_caching_allocator<char,
-                    hpx::util::internal_allocator<>>;
+            using allocator_type = hpx::util::thread_local_caching_allocator<
+                hpx::lockfree::variable_size_stack, char,
+                hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -710,9 +714,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type =
-                hpx::util::thread_local_caching_allocator<char,
-                    hpx::util::internal_allocator<>>;
+            using allocator_type = hpx::util::thread_local_caching_allocator<
+                hpx::lockfree::variable_size_stack, char,
+                hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -739,9 +743,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type =
-                hpx::util::thread_local_caching_allocator<char,
-                    hpx::util::internal_allocator<>>;
+            using allocator_type = hpx::util::thread_local_caching_allocator<
+                hpx::lockfree::variable_size_stack, char,
+                hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});