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 | 133 |
1 files changed, 116 insertions, 17 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..14033a49a16 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-2021 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,6 +18,8 @@ #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" @@ -28,12 +30,45 @@ // asio_handler_alloc_helpers namespace is defined here for that purpose. namespace asio_handler_alloc_helpers { +#if defined(ASIO_NO_DEPRECATED) template <typename Handler> -inline void* allocate(std::size_t s, Handler& h) +inline void error_if_hooks_are_defined(Handler& h) +{ + using asio::asio_handler_allocate; + // If you get an error here it is because some of your handlers still + // overload asio_handler_allocate, but this hook is no longer used. + (void)static_cast<asio::asio_handler_allocate_is_no_longer_used>( + asio_handler_allocate(static_cast<std::size_t>(0), + asio::detail::addressof(h))); + + using asio::asio_handler_deallocate; + // If you get an error here it is because some of your handlers still + // overload asio_handler_deallocate, but this hook is no longer used. + (void)static_cast<asio::asio_handler_deallocate_is_no_longer_used>( + asio_handler_deallocate(static_cast<void*>(0), + static_cast<std::size_t>(0), asio::detail::addressof(h))); +} +#endif // defined(ASIO_NO_DEPRECATED) + +template <typename Handler> +inline void* allocate(std::size_t s, Handler& h, + std::size_t align = ASIO_DEFAULT_ALIGN) { #if !defined(ASIO_HAS_HANDLER_HOOKS) - return ::operator new(s); + return aligned_new(align, s); +#elif defined(ASIO_NO_DEPRECATED) + // The asio_handler_allocate hook is no longer used to obtain memory. + (void)&error_if_hooks_are_defined<Handler>; + (void)h; +# 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 aligned_new(align, s); +# endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING) #else + (void)align; using asio::asio_handler_allocate; return asio_handler_allocate(s, asio::detail::addressof(h)); #endif @@ -43,7 +78,18 @@ template <typename Handler> inline void deallocate(void* p, std::size_t s, Handler& h) { #if !defined(ASIO_HAS_HANDLER_HOOKS) - ::operator delete(p); + aligned_delete(p); +#elif defined(ASIO_NO_DEPRECATED) + // The asio_handler_allocate hook is no longer used to obtain memory. + (void)&error_if_hooks_are_defined<Handler>; + (void)h; +#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; + aligned_delete(p); +#endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING) #else using asio::asio_handler_deallocate; asio_handler_deallocate(p, s, asio::detail::addressof(h)); @@ -59,6 +105,8 @@ template <typename Handler, typename T> class hook_allocator { public: + typedef T value_type; + template <typename U> struct rebind { @@ -79,7 +127,8 @@ public: T* allocate(std::size_t n) { return static_cast<T*>( - asio_handler_alloc_helpers::allocate(sizeof(T) * n, handler_)); + asio_handler_alloc_helpers::allocate( + sizeof(T) * n, handler_, ASIO_ALIGNOF(T))); } void deallocate(T* p, std::size_t n) @@ -95,6 +144,8 @@ template <typename Handler> class hook_allocator<Handler, void> { public: + typedef void value_type; + template <typename U> struct rebind { @@ -116,15 +167,34 @@ public: Handler& handler_; }; +template <typename Handler, typename Allocator> +struct get_hook_allocator +{ + typedef Allocator type; + + static type get(Handler&, const Allocator& a) + { + return a; + } +}; + +template <typename Handler, typename T> +struct get_hook_allocator<Handler, std::allocator<T> > +{ + typedef hook_allocator<Handler, T> type; + + static type get(Handler& handler, const std::allocator<T>&) + { + return type(handler); + } +}; + } // namespace detail } // namespace asio #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 +204,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_hook_allocator< \ + Handler, associated_allocator_type>::type hook_allocator_type; \ + ASIO_REBIND_ALLOC(hook_allocator_type, op) a( \ + ::asio::detail::get_hook_allocator< \ + Handler, associated_allocator_type>::get( \ + handler, ::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 +223,14 @@ public: } \ if (v) \ { \ + typedef typename ::asio::associated_allocator< \ + Handler>::type associated_allocator_type; \ + typedef typename ::asio::detail::get_hook_allocator< \ + Handler, associated_allocator_type>::type hook_allocator_type; \ + ASIO_REBIND_ALLOC(hook_allocator_type, op) a( \ + ::asio::detail::get_hook_allocator< \ + Handler, associated_allocator_type>::get( \ + *h, ::asio::get_associated_allocator(*h))); \ a.deallocate(static_cast<op*>(v), 1); \ v = 0; \ } \ @@ -158,16 +238,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 +266,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 |