From 2b0bb2c5f3163e0a30bd33616b10be809536719c Mon Sep 17 00:00:00 2001
From: Hartmut Kaiser <hartmut.kaiser@gmail.com>
Date: Mon, 16 Sep 2024 19:12:17 -0500
Subject: [PATCH] Factoring out allocator cache

---
 libs/core/allocator_support/CMakeLists.txt    |   5 +-
 .../thread_local_caching_allocator.hpp        | 161 +++++++++---------
 .../src/thread_local_caching_allocator.cpp    | 120 +++++++++++++
 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        |   4 +-
 .../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     |   4 +-
 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 +++---
 21 files changed, 267 insertions(+), 190 deletions(-)
 create mode 100644 libs/core/allocator_support/src/thread_local_caching_allocator.cpp

diff --git a/libs/core/allocator_support/CMakeLists.txt b/libs/core/allocator_support/CMakeLists.txt
index 1e5bcb0f10ab..9464a7dd3392 100644
--- a/libs/core/allocator_support/CMakeLists.txt
+++ b/libs/core/allocator_support/CMakeLists.txt
@@ -42,7 +42,7 @@ set(allocator_support_compat_headers
 )
 # cmake-format: on
 
-set(allocator_support_sources)
+set(allocator_support_sources thread_local_caching_allocator.cpp)
 
 include(HPX_AddModule)
 add_hpx_module(
@@ -52,6 +52,7 @@ add_hpx_module(
   HEADERS ${allocator_support_headers}
   COMPAT_HEADERS ${allocator_support_compat_headers}
   DEPENDENCIES hpx_dependencies_allocator
-  MODULE_DEPENDENCIES hpx_concepts hpx_config hpx_preprocessor hpx_type_support
+  MODULE_DEPENDENCIES hpx_assertion hpx_concepts hpx_config hpx_preprocessor
+                      hpx_type_support
   CMAKE_SUBDIRS examples tests
 )
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 0afd89a7c3fe..144542ba1b40 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
@@ -8,8 +8,10 @@
 
 #include <hpx/config.hpp>
 #include <hpx/allocator_support/config/defines.hpp>
+#include <hpx/assert.hpp>
 
 #include <cstddef>
+#include <functional>
 #include <memory>
 #include <new>
 #include <type_traits>
@@ -21,15 +23,41 @@ namespace hpx::util {
     !((defined(HPX_HAVE_CUDA) && defined(__CUDACC__)) ||                       \
         defined(HPX_HAVE_HIP))
 
+    namespace detail {
+
+        HPX_CORE_EXPORT void init_allocator_cache(
+            std::size_t, std::function<void()>&& clear_cache);
+        HPX_CORE_EXPORT std::pair<void*, std::size_t> allocate_from_cache(
+            std::size_t) noexcept;
+        [[nodiscard]] HPX_CORE_EXPORT bool cache_empty(std::size_t) noexcept;
+        HPX_CORE_EXPORT void return_to_cache(
+            std::size_t, void* p, std::size_t n) noexcept;
+
+        // maximal number of caches [0...max)
+        inline constexpr int max_number_of_caches = 16;
+
+        ///////////////////////////////////////////////////////////////////////
+        constexpr int next_power_of_two(std::int64_t n) noexcept
+        {
+            int i = 0;
+            for (--n; n > 0; n >>= 1)
+            {
+                ++i;
+            }
+            return i;
+        }
+    }    // namespace detail
+
     ///////////////////////////////////////////////////////////////////////////
-    template <template <typename, typename> class Stack, typename T = char,
-        typename Allocator = std::allocator<T>>
+    template <typename T = char, typename Allocator = std::allocator<T>>
     struct thread_local_caching_allocator
     {
         HPX_NO_UNIQUE_ADDRESS Allocator alloc;
 
+    private:
         using traits = std::allocator_traits<Allocator>;
 
+    public:
         using value_type = typename traits::value_type;
         using pointer = typename traits::pointer;
         using const_pointer = typename traits::const_pointer;
@@ -39,7 +67,7 @@ namespace hpx::util {
         template <typename U>
         struct rebind
         {
-            using other = thread_local_caching_allocator<Stack, U,
+            using other = thread_local_caching_allocator<U,
                 typename traits::template rebind_alloc<U>>;
         };
 
@@ -51,91 +79,43 @@ namespace hpx::util {
         using propagate_on_container_swap =
             typename traits::propagate_on_container_swap;
 
-    private:
-        struct allocated_cache
+        explicit thread_local_caching_allocator(
+            Allocator const& alloc = Allocator{}) noexcept(noexcept(std::
+                is_nothrow_copy_constructible_v<Allocator>))
+          : alloc(alloc)
         {
-            explicit allocated_cache(Allocator const& a) noexcept(
-                noexcept(std::is_nothrow_copy_constructible_v<Allocator>))
-              : alloc(a)
-              , data(0)
-            {
-            }
-
-            allocated_cache(allocated_cache const&) = delete;
-            allocated_cache(allocated_cache&&) = delete;
-            allocated_cache& operator=(allocated_cache const&) = delete;
-            allocated_cache& operator=(allocated_cache&&) = delete;
-
-            ~allocated_cache()
-            {
-                clear_cache();
-            }
-
-            pointer allocate(size_type n)
-            {
-                pointer p;
-                std::pair<T*, size_type> pair;
-                if (data.pop(pair))
-                {
-                    p = pair.first;
-                }
-                else
+            // Note: capturing the allocator will be ok only as long as it
+            // doesn't have any state as this lambda will be possibly called
+            // very late during destruction of the thread_local cache.
+            static_assert(std::is_empty_v<Allocator>,
+                "Please don't use allocators with state in conjunction with "
+                "the thread_local_caching_allocator");
+
+            constexpr std::size_t num_cache =
+                detail::next_power_of_two(sizeof(T));
+
+            static_assert(num_cache < detail::max_number_of_caches,
+                "This allocator does not support allocating objects larger "
+                "than 2^16 bytes");
+
+            auto f = [alloc]() mutable {
+                while (!detail::cache_empty(num_cache))
                 {
-                    p = traits::allocate(alloc, n);
-                    if (p == nullptr)
+                    auto [p, n] = detail::allocate_from_cache(num_cache);
+                    if (p != nullptr)
                     {
-                        throw std::bad_alloc();
+                        traits::deallocate(const_cast<Allocator&>(alloc),
+                            static_cast<char*>(p), n);
                     }
                 }
+            };
 
-                ++allocated;
-                return p;
-            }
-
-            void deallocate(pointer p, size_type n) noexcept
-            {
-                data.push(std::make_pair(p, n));
-                if (++deallocated > 2 * (allocated + 16))
-                {
-                    clear_cache();
-                    allocated = 0;
-                    deallocated = 0;
-                }
-            }
-
-        private:
-            void clear_cache() noexcept
-            {
-                std::pair<T*, size_type> p;
-                while (data.pop(p))
-                {
-                    traits::deallocate(alloc, p.first, p.second);
-                }
-            }
-
-            HPX_NO_UNIQUE_ADDRESS Allocator alloc;
-            Stack<std::pair<T*, size_type>, Allocator> data;
-            std::size_t allocated = 0;
-            std::size_t deallocated = 0;
-        };
-
-        allocated_cache& cache()
-        {
-            thread_local allocated_cache allocated_data(alloc);
-            return allocated_data;
-        }
-
-    public:
-        explicit thread_local_caching_allocator(
-            Allocator const& alloc = Allocator{}) noexcept(noexcept(std::
-                is_nothrow_copy_constructible_v<Allocator>))
-          : alloc(alloc)
-        {
+            detail::init_allocator_cache(num_cache, HPX_MOVE(f));
         }
 
         template <typename U, typename Alloc>
         explicit thread_local_caching_allocator(
-            thread_local_caching_allocator<Stack, U, Alloc> const&
+            thread_local_caching_allocator<U, Alloc> const&
                 rhs) noexcept(noexcept(std::
                 is_nothrow_copy_constructible_v<Alloc>))
           : alloc(rhs.alloc)
@@ -155,16 +135,32 @@ namespace hpx::util {
 
         [[nodiscard]] pointer allocate(size_type n, void const* = nullptr)
         {
-            if (max_size() < n)
+            constexpr std::size_t num_cache =
+                detail::next_power_of_two(sizeof(T));
+            std::size_t N = n * (1ull << num_cache);
+
+            if (max_size() < N)
             {
                 throw std::bad_array_new_length();
             }
-            return cache().allocate(n);
+
+            auto [p, _] = detail::allocate_from_cache(num_cache);
+            if (p == nullptr)
+            {
+                p = traits::allocate(alloc, N);
+                if (p == nullptr)
+                {
+                    throw std::bad_alloc();
+                }
+            }
+            return static_cast<pointer>(p);
         }
 
         void deallocate(pointer p, size_type n) noexcept
         {
-            cache().deallocate(p, n);
+            constexpr std::size_t num_cache =
+                detail::next_power_of_two(sizeof(T));
+            detail::return_to_cache(num_cache, p, n * (1ull << num_cache));
         }
 
         [[nodiscard]] constexpr size_type max_size() noexcept
@@ -199,8 +195,7 @@ namespace hpx::util {
         }
     };
 #else
-    template <template <typename, typename> class Stack, typename T = char,
-        typename Allocator = std::allocator<T>>
+    template <typename T = char, typename Allocator = std::allocator<T>>
     using thread_local_caching_allocator = Allocator;
 #endif
 }    // namespace hpx::util
diff --git a/libs/core/allocator_support/src/thread_local_caching_allocator.cpp b/libs/core/allocator_support/src/thread_local_caching_allocator.cpp
new file mode 100644
index 000000000000..7758fe5e81aa
--- /dev/null
+++ b/libs/core/allocator_support/src/thread_local_caching_allocator.cpp
@@ -0,0 +1,120 @@
+//  Copyright (c) 2023-2024 Hartmut Kaiser
+//
+//  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 <hpx/config.hpp>
+#include <hpx/allocator_support/config/defines.hpp>
+
+#if defined(HPX_ALLOCATOR_SUPPORT_HAVE_CACHING) &&                             \
+    !((defined(HPX_HAVE_CUDA) && defined(__CUDACC__)) ||                       \
+        defined(HPX_HAVE_HIP))
+
+#include <hpx/allocator_support/thread_local_caching_allocator.hpp>
+#include <hpx/assert.hpp>
+
+#include <cstddef>
+#include <functional>
+#include <stack>
+#include <utility>
+
+namespace hpx::util::detail {
+
+    ///////////////////////////////////////////////////////////////////////////
+    struct allocated_cache
+    {
+        explicit allocated_cache() noexcept = default;
+
+        void init(std::function<void()>&& clear) noexcept
+        {
+            if (!clear_cache)    // initialize once
+            {
+                clear_cache = HPX_MOVE(clear);
+            }
+        }
+
+        allocated_cache(allocated_cache const&) = delete;
+        allocated_cache(allocated_cache&&) = delete;
+        allocated_cache& operator=(allocated_cache const&) = delete;
+        allocated_cache& operator=(allocated_cache&&) = delete;
+
+        ~allocated_cache()
+        {
+            if (clear_cache)
+            {
+                clear_cache();
+            }
+        }
+
+        std::pair<void*, std::size_t> allocate() noexcept
+        {
+            std::pair<void*, std::size_t> p{nullptr, 0};
+            if (!data.empty())
+            {
+                p = data.top();
+                data.pop();
+
+                ++allocated;
+            }
+            return p;
+        }
+
+        void deallocate(void* p, std::size_t n) noexcept
+        {
+            data.emplace(p, n);
+            if (++deallocated > 2 * (allocated + 16))
+            {
+                HPX_ASSERT(clear_cache);    // must have been initialized
+                clear_cache();
+
+                allocated = 0;
+                deallocated = 0;
+            }
+        }
+
+        [[nodiscard]] bool empty() const noexcept
+        {
+            return data.empty();
+        }
+
+    private:
+        std::stack<std::pair<void*, std::size_t>> data;
+        std::size_t allocated = 0;
+        std::size_t deallocated = 0;
+        std::function<void()> clear_cache;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    allocated_cache& cache(std::size_t n)
+    {
+        HPX_ASSERT(n < max_number_of_caches);
+
+        thread_local allocated_cache allocated_data[max_number_of_caches];
+        return allocated_data[n];
+    }
+
+    void init_allocator_cache(
+        std::size_t n, std::function<void()>&& clear_cache)
+    {
+        cache(n).init(HPX_MOVE(clear_cache));
+    }
+
+    std::pair<void*, std::size_t> allocate_from_cache(std::size_t n) noexcept
+    {
+        return cache(n).allocate();
+    }
+
+    void return_to_cache(
+        std::size_t n, void* p, std::size_t const size) noexcept
+    {
+        cache(n).deallocate(p, size);
+    }
+
+    bool cache_empty(std::size_t n) noexcept
+    {
+        return cache(n).empty();
+    }
+}    // namespace hpx::util::detail
+
+#endif
diff --git a/libs/core/async_base/CMakeLists.txt b/libs/core/async_base/CMakeLists.txt
index 6a18a9e12b7a..acd6ff32e0de 100644
--- a/libs/core/async_base/CMakeLists.txt
+++ b/libs/core/async_base/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2024 The STE||AR-Group
+# Copyright (c) 2020-2022 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_concurrency hpx_coroutines hpx_tag_invoke
+                      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 a6a3bb790bdf..6015ab1b6091 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-2024 Hartmut Kaiser
+//  Copyright (c) 2007-2022 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -29,7 +29,6 @@ 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>
@@ -61,14 +60,12 @@ 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<
-                                    hpx::lockfree::variable_size_stack, char,
+                -> decltype(tag(hpx::util::thread_local_caching_allocator<char,
                                     hpx::util::internal_allocator<>>{},
                     HPX_FORWARD(F, f), HPX_FORWARD(Ts, ts)...))
             {
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<
-                        hpx::lockfree::variable_size_stack, char,
+                    hpx::util::thread_local_caching_allocator<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 ff730d928fe7..b7cf2059b489 100644
--- a/libs/core/async_combinators/CMakeLists.txt
+++ b/libs/core/async_combinators/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2024 The STE||AR-Group
+# Copyright (c) 2019-2023 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -43,7 +43,6 @@ 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 3f4d400e5eea..8fff887a6276 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
@@ -131,7 +131,6 @@ 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>
@@ -229,8 +228,7 @@ 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<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<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 b80922e6e434..ffeb832a40dc 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-2024 Hartmut Kaiser
+//  Copyright (c) 2022-2023 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -770,10 +770,4 @@ 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 f080a049738a..cd15bb0b581f 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 variable_size_stack_test()
+void fixed_size_stack_test()
 {
     hpx::lockfree::stack<long, std::allocator<long>, 128> stk;
 
@@ -89,7 +89,7 @@ void variable_size_stack_test()
     HPX_TEST(stk.empty());
 }
 
-void variable_size_stack_test_exhausted()
+void fixed_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();
-    variable_size_stack_test();
-    variable_size_stack_test_exhausted();
+    fixed_size_stack_test();
+    fixed_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 0f36cbc43993..2f6cde663464 100644
--- a/libs/core/execution/CMakeLists.txt
+++ b/libs/core/execution/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2024 The STE||AR-Group
+# Copyright (c) 2019-2022 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -160,7 +160,6 @@ 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 a8d644afe1c0..367bd58f9496 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-2024 Hartmut Kaiser
+//  Copyright (c) 2007-2022 Hartmut Kaiser
 //  Copyright (c) 2013 Agustin Berge
 //
 //  SPDX-License-Identifier: BSL-1.0
@@ -13,7 +13,6 @@
 #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>
@@ -65,9 +64,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<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<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 43985414eaed..1e0c7e5b3a53 100644
--- a/libs/core/executors/CMakeLists.txt
+++ b/libs/core/executors/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2024 The STE||AR-Group
+# Copyright (c) 2020-2022 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -97,7 +97,6 @@ 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 915551b7c579..abedc6fd341f 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-2024 Hartmut Kaiser
+//  Copyright (c) 2007-2023 Hartmut Kaiser
 //  Copyright (c) 2019 Agustin Berge
 //
 //  SPDX-License-Identifier: BSL-1.0
@@ -12,7 +12,6 @@
 #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>
@@ -390,9 +389,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<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<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 bf0bd5c68214..3387538bd92b 100644
--- a/libs/core/futures/CMakeLists.txt
+++ b/libs/core/futures/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2024 The STE||AR-Group
+# Copyright (c) 2019-2022 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -68,7 +68,6 @@ 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 7d83b551b362..6a1a2ef58b8a 100644
--- a/libs/core/futures/include/hpx/futures/future.hpp
+++ b/libs/core/futures/include/hpx/futures/future.hpp
@@ -18,7 +18,6 @@
 #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>
@@ -379,14 +378,13 @@ 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<
-                    hpx::lockfree::variable_size_stack, char,
+                hpx::util::thread_local_caching_allocator<char,
                     hpx::util::internal_allocator<>>{},
                 HPX_MOVE(fut), HPX_FORWARD(F, f)))
         {
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
 
             using result_type =
                 decltype(future_then_dispatch<std::decay_t<F>>::call_alloc(
@@ -406,14 +404,13 @@ 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<
-                    hpx::lockfree::variable_size_stack, char,
+                hpx::util::thread_local_caching_allocator<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<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
 
             using result_type =
                 decltype(future_then_dispatch<std::decay_t<T0>>::call_alloc(
@@ -1249,8 +1246,7 @@ 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<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return make_ready_future_alloc<T>(
             allocator_type{}, HPX_FORWARD(Ts, ts)...);
@@ -1274,8 +1270,7 @@ 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<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<hpx::util::decay_unwrap_t<T>>(
             allocator_type{}, HPX_FORWARD(T, init));
@@ -1356,8 +1351,7 @@ 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<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return make_ready_future_alloc<void>(allocator_type{}, util::unused);
     }
@@ -1599,8 +1593,7 @@ 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<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<T>(
             allocator_type{}, HPX_FORWARD(Ts, ts)...);
@@ -1623,8 +1616,7 @@ 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<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<hpx::util::decay_unwrap_t<T>>(
             allocator_type{}, HPX_FORWARD(T, init));
@@ -1683,8 +1675,7 @@ namespace hpx::lcos {
         "hpx::make_ready_future instead.")
     inline hpx::future<void> make_ready_future()
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<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 3898333e56ee..ac412045a4ee 100644
--- a/libs/core/futures/include/hpx/futures/futures_factory.hpp
+++ b/libs/core/futures/include/hpx/futures/futures_factory.hpp
@@ -12,7 +12,6 @@
 #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>
@@ -771,8 +770,7 @@ 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<
-                    hpx::lockfree::variable_size_stack, char,
+                hpx::util::thread_local_caching_allocator<char,
                     hpx::util::internal_allocator<>>{},
                 HPX_FORWARD(F, f)))
         {
@@ -780,8 +778,7 @@ namespace hpx::lcos::local {
 
         explicit futures_factory(Result (*f)())
           : task_(detail::create_task_object<Result, Cancelable>::call(
-                hpx::util::thread_local_caching_allocator<
-                    hpx::lockfree::variable_size_stack, char,
+                hpx::util::thread_local_caching_allocator<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 204f52bd10e9..a7af9ea93e20 100644
--- a/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
+++ b/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
@@ -13,7 +13,6 @@
 #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>
@@ -584,8 +583,7 @@ namespace hpx::lcos::detail {
     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<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<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 b590593d9a31..d4978905a229 100644
--- a/libs/core/lcos_local/CMakeLists.txt
+++ b/libs/core/lcos_local/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2024 The STE||AR-Group
+# Copyright (c) 2019-2023 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -48,7 +48,6 @@ 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 1961bc916147..bf5134ae1a8f 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,7 +10,6 @@
 #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>
@@ -52,8 +51,7 @@ 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<
-                    hpx::lockfree::variable_size_stack, char,
+                hpx::util::thread_local_caching_allocator<char,
                     hpx::util::internal_allocator<>>{})
           , generation_(1)
         {
@@ -211,8 +209,7 @@ namespace hpx::lcos::local {
                 {
                     // we have received the last missing segment
                     using allocator_type =
-                        hpx::util::thread_local_caching_allocator<
-                            hpx::lockfree::variable_size_stack, char,
+                        hpx::util::thread_local_caching_allocator<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 3fbfefc16daf..8be2723538a8 100644
--- a/libs/full/async_distributed/CMakeLists.txt
+++ b/libs/full/async_distributed/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2024 The STE||AR-Group
+# Copyright (c) 2019-2023 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 d1fe5b1edce7..35a1479f955d 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-2024 Hartmut Kaiser
+//  Copyright (c) 2007-2023 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -17,7 +17,6 @@
 #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>
@@ -205,8 +204,7 @@ namespace hpx::detail {
                 handle_managed_target<Result> hmt(id, f);
 
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<
-                        hpx::lockfree::variable_size_stack, char,
+                    hpx::util::thread_local_caching_allocator<char,
                         hpx::util::internal_allocator<>>;
                 lcos::packaged_action<Action, Result> p(
                     std::allocator_arg, allocator_type{});
@@ -234,9 +232,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -260,9 +258,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -286,9 +284,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -550,8 +548,7 @@ namespace hpx::detail {
             if (policy == launch::sync || hpx::detail::has_async_policy(policy))
             {
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<
-                        hpx::lockfree::variable_size_stack, char,
+                    hpx::util::thread_local_caching_allocator<char,
                         hpx::util::internal_allocator<>>;
                 lcos::packaged_action<action_type, result_type> p(
                     std::allocator_arg, allocator_type{});
@@ -565,8 +562,7 @@ namespace hpx::detail {
             else if (policy == launch::deferred)
             {
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<
-                        hpx::lockfree::variable_size_stack, char,
+                    hpx::util::thread_local_caching_allocator<char,
                         hpx::util::internal_allocator<>>;
                 lcos::packaged_action<action_type, result_type> p(
                     std::allocator_arg, allocator_type{});
@@ -634,9 +630,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -714,9 +710,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -743,9 +739,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});