diff options
Diffstat (limited to '3rdparty/asio/include/asio/detail/handler_alloc_helpers.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/detail/handler_alloc_helpers.hpp | 158 |
1 files changed, 97 insertions, 61 deletions
diff --git a/3rdparty/asio/include/asio/detail/handler_alloc_helpers.hpp b/3rdparty/asio/include/asio/detail/handler_alloc_helpers.hpp index 0658b9883f1..c14d542e48c 100644 --- a/3rdparty/asio/include/asio/detail/handler_alloc_helpers.hpp +++ b/3rdparty/asio/include/asio/detail/handler_alloc_helpers.hpp @@ -2,7 +2,7 @@ // detail/handler_alloc_helpers.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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) @@ -18,102 +18,112 @@ #include "asio/detail/config.hpp" #include "asio/detail/memory.hpp" #include "asio/detail/noncopyable.hpp" +#include "asio/detail/recycling_allocator.hpp" +#include "asio/detail/thread_info_base.hpp" #include "asio/associated_allocator.hpp" -#include "asio/handler_alloc_hook.hpp" #include "asio/detail/push_options.hpp" -// Calls to asio_handler_allocate and asio_handler_deallocate must be made from -// a namespace that does not contain any overloads of these functions. The -// asio_handler_alloc_helpers namespace is defined here for that purpose. -namespace asio_handler_alloc_helpers { +namespace asio { +namespace detail { -template <typename Handler> -inline void* allocate(std::size_t s, Handler& h) +inline void* default_allocate(std::size_t s, + std::size_t align = ASIO_DEFAULT_ALIGN) { -#if !defined(ASIO_HAS_HANDLER_HOOKS) - return ::operator new(s); -#else - using asio::asio_handler_allocate; - return asio_handler_allocate(s, asio::detail::addressof(h)); -#endif +#if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING) + return asio::detail::thread_info_base::allocate( + asio::detail::thread_context::top_of_thread_call_stack(), + s, align); +#else // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING) + return asio::aligned_new(align, s); +#endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING) } -template <typename Handler> -inline void deallocate(void* p, std::size_t s, Handler& h) +inline void default_deallocate(void* p, std::size_t s) { -#if !defined(ASIO_HAS_HANDLER_HOOKS) - ::operator delete(p); -#else - using asio::asio_handler_deallocate; - asio_handler_deallocate(p, s, asio::detail::addressof(h)); -#endif +#if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING) + asio::detail::thread_info_base::deallocate( + asio::detail::thread_context::top_of_thread_call_stack(), p, s); +#else // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING) + (void)s; + asio::aligned_delete(p); +#endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING) } -} // namespace asio_handler_alloc_helpers - -namespace asio { -namespace detail { - -template <typename Handler, typename T> -class hook_allocator +template <typename T> +class default_allocator { public: + typedef T value_type; + template <typename U> struct rebind { - typedef hook_allocator<Handler, U> other; + typedef default_allocator<U> other; }; - explicit hook_allocator(Handler& h) - : handler_(h) + default_allocator() noexcept { } template <typename U> - hook_allocator(const hook_allocator<Handler, U>& a) - : handler_(a.handler_) + default_allocator(const default_allocator<U>&) noexcept { } T* allocate(std::size_t n) { - return static_cast<T*>( - asio_handler_alloc_helpers::allocate(sizeof(T) * n, handler_)); + return static_cast<T*>(default_allocate(sizeof(T) * n, alignof(T))); } void deallocate(T* p, std::size_t n) { - asio_handler_alloc_helpers::deallocate(p, sizeof(T) * n, handler_); + default_deallocate(p, sizeof(T) * n); } - -//private: - Handler& handler_; }; -template <typename Handler> -class hook_allocator<Handler, void> +template <> +class default_allocator<void> { public: + typedef void value_type; + template <typename U> struct rebind { - typedef hook_allocator<Handler, U> other; + typedef default_allocator<U> other; }; - explicit hook_allocator(Handler& h) - : handler_(h) + default_allocator() noexcept { } template <typename U> - hook_allocator(const hook_allocator<Handler, U>& a) - : handler_(a.handler_) + default_allocator(const default_allocator<U>&) noexcept { } +}; -//private: - Handler& handler_; +template <typename Allocator> +struct get_default_allocator +{ + typedef Allocator type; + + static type get(const Allocator& a) + { + return a; + } +}; + +template <typename T> +struct get_default_allocator<std::allocator<T>> +{ + typedef default_allocator<T> type; + + static type get(const std::allocator<T>&) + { + return type(); + } }; } // namespace detail @@ -122,9 +132,6 @@ public: #define ASIO_DEFINE_HANDLER_PTR(op) \ struct ptr \ { \ - typedef typename ::asio::associated_allocator<Handler, \ - ::asio::detail::hook_allocator<Handler, \ - void> >::type::template rebind<op>::other allocator_type; \ Handler* h; \ op* v; \ op* p; \ @@ -134,16 +141,18 @@ public: } \ static op* allocate(Handler& handler) \ { \ - allocator_type a(::asio::associated_allocator<Handler, \ - ::asio::detail::hook_allocator<Handler, void> >::get(handler, \ - ::asio::detail::hook_allocator<Handler, void>(handler))); \ + typedef typename ::asio::associated_allocator< \ + Handler>::type associated_allocator_type; \ + typedef typename ::asio::detail::get_default_allocator< \ + associated_allocator_type>::type default_allocator_type; \ + ASIO_REBIND_ALLOC(default_allocator_type, op) a( \ + ::asio::detail::get_default_allocator< \ + associated_allocator_type>::get( \ + ::asio::get_associated_allocator(handler))); \ return a.allocate(1); \ } \ void reset() \ { \ - allocator_type a(::asio::associated_allocator<Handler, \ - ::asio::detail::hook_allocator<Handler, void> >::get(*h, \ - ::asio::detail::hook_allocator<Handler, void>(*h))); \ if (p) \ { \ p->~op(); \ @@ -151,6 +160,14 @@ public: } \ if (v) \ { \ + typedef typename ::asio::associated_allocator< \ + Handler>::type associated_allocator_type; \ + typedef typename ::asio::detail::get_default_allocator< \ + associated_allocator_type>::type default_allocator_type; \ + ASIO_REBIND_ALLOC(default_allocator_type, op) a( \ + ::asio::detail::get_default_allocator< \ + associated_allocator_type>::get( \ + ::asio::get_associated_allocator(*h))); \ a.deallocate(static_cast<op*>(v), 1); \ v = 0; \ } \ @@ -158,16 +175,25 @@ public: } \ /**/ -#define ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(op, alloc) \ +#define ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR(purpose, op) \ struct ptr \ { \ - typename alloc::template rebind<op>::other a; \ + const Alloc* a; \ void* v; \ op* p; \ ~ptr() \ { \ reset(); \ } \ + static op* allocate(const Alloc& a) \ + { \ + typedef typename ::asio::detail::get_recycling_allocator< \ + Alloc, purpose>::type recycling_allocator_type; \ + ASIO_REBIND_ALLOC(recycling_allocator_type, op) a1( \ + ::asio::detail::get_recycling_allocator< \ + Alloc, purpose>::get(a)); \ + return a1.allocate(1); \ + } \ void reset() \ { \ if (p) \ @@ -177,13 +203,23 @@ public: } \ if (v) \ { \ - a.deallocate(static_cast<op*>(v), 1); \ + typedef typename ::asio::detail::get_recycling_allocator< \ + Alloc, purpose>::type recycling_allocator_type; \ + ASIO_REBIND_ALLOC(recycling_allocator_type, op) a1( \ + ::asio::detail::get_recycling_allocator< \ + Alloc, purpose>::get(*a)); \ + a1.deallocate(static_cast<op*>(v), 1); \ v = 0; \ } \ } \ } \ /**/ +#define ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(op) \ + ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR( \ + ::asio::detail::thread_info_base::default_tag, op ) \ + /**/ + #include "asio/detail/pop_options.hpp" #endif // ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP |