Use execution_context allocator in timer queues.

Added new configuration parameter "timer" / "heap_reserve" that may be
used to reserve space in the vector used for a timer queue's heap.

Author: chriskohlhoff

asio/include/asio/detail/deadline_timer_service.hpp

@@ -19,6 +19,7 @@
 #include <cstddef>
 #include "asio/associated_cancellation_slot.hpp"
 #include "asio/cancellation_type.hpp"
+#include "asio/config.hpp"
 #include "asio/error.hpp"
 #include "asio/execution_context.hpp"
 #include "asio/detail/bind_handler.hpp"
@@ -43,16 +44,19 @@
 namespace asio {
 namespace detail {
 
-template <typename Time_Traits>
+template <typename TimeTraits>
 class deadline_timer_service
-  : public execution_context_service_base<deadline_timer_service<Time_Traits>>
+  : public execution_context_service_base<deadline_timer_service<TimeTraits>>
 {
 public:
   // The time type.
-  typedef typename Time_Traits::time_type time_type;
+  typedef typename TimeTraits::time_type time_type;
 
   // The duration type.
-  typedef typename Time_Traits::duration_type duration_type;
+  typedef typename TimeTraits::duration_type duration_type;
+
+  // The allocator type.
+  typedef execution_context::allocator<void> allocator_type;
 
   // The implementation type of the timer. This type is dependent on the
   // underlying implementation of the timer service.
@@ -61,13 +65,15 @@ class deadline_timer_service
   {
     time_type expiry;
     bool might_have_pending_waits;
-    typename timer_queue<Time_Traits>::per_timer_data timer_data;
+    typename timer_queue<TimeTraits, allocator_type>::per_timer_data timer_data;
   };
 
   // Constructor.
   deadline_timer_service(execution_context& context)
     : execution_context_service_base<
-        deadline_timer_service<Time_Traits>>(context),
+        deadline_timer_service<TimeTraits>>(context),
+      timer_queue_(allocator_type(context),
+          config(context).get("timer", "heap_reserve", 0U)),
       scheduler_(asio::use_service<timer_scheduler>(context))
   {
     scheduler_.init_task();
@@ -204,7 +210,7 @@ class deadline_timer_service
   // Get the expiry time for the timer relative to now.
   duration_type expires_from_now(const implementation_type& impl) const
   {
-    return Time_Traits::subtract(this->expiry(impl), Time_Traits::now());
+    return TimeTraits::subtract(this->expiry(impl), TimeTraits::now());
   }
 
   // Set the expiry time for the timer as an absolute time.
@@ -222,27 +228,27 @@ class deadline_timer_service
       const duration_type& expiry_time, asio::error_code& ec)
   {
     return expires_at(impl,
-        Time_Traits::add(Time_Traits::now(), expiry_time), ec);
+        TimeTraits::add(TimeTraits::now(), expiry_time), ec);
   }
 
   // Set the expiry time for the timer relative to now.
   std::size_t expires_from_now(implementation_type& impl,
       const duration_type& expiry_time, asio::error_code& ec)
   {
     return expires_at(impl,
-        Time_Traits::add(Time_Traits::now(), expiry_time), ec);
+        TimeTraits::add(TimeTraits::now(), expiry_time), ec);
   }
 
   // Perform a blocking wait on the timer.
   void wait(implementation_type& impl, asio::error_code& ec)
   {
-    time_type now = Time_Traits::now();
+    time_type now = TimeTraits::now();
     ec = asio::error_code();
-    while (Time_Traits::less_than(now, impl.expiry) && !ec)
+    while (TimeTraits::less_than(now, impl.expiry) && !ec)
     {
-      this->do_wait(Time_Traits::to_posix_duration(
-            Time_Traits::subtract(impl.expiry, now)), ec);
-      now = Time_Traits::now();
+      this->do_wait(TimeTraits::to_posix_duration(
+            TimeTraits::subtract(impl.expiry, now)), ec);
+      now = TimeTraits::now();
     }
   }
 
@@ -301,7 +307,7 @@ class deadline_timer_service
   {
   public:
     op_cancellation(deadline_timer_service* s,
-        typename timer_queue<Time_Traits>::per_timer_data* p)
+        typename timer_queue<TimeTraits, allocator_type>::per_timer_data* p)
       : service_(s),
         timer_data_(p)
     {
@@ -321,11 +327,12 @@ class deadline_timer_service
 
   private:
     deadline_timer_service* service_;
-    typename timer_queue<Time_Traits>::per_timer_data* timer_data_;
+    typename timer_queue<TimeTraits, allocator_type>::per_timer_data*
+      timer_data_;
   };
 
   // The queue of timers.
-  timer_queue<Time_Traits> timer_queue_;
+  timer_queue<TimeTraits, allocator_type> timer_queue_;
 
   // The object that schedules and executes timers. Usually a reactor.
   timer_scheduler& scheduler_;

asio/include/asio/detail/dev_poll_reactor.hpp

@@ -140,38 +140,39 @@ class dev_poll_reactor
   ASIO_DECL void cleanup_descriptor_data(per_descriptor_data&);
 
   // Add a new timer queue to the reactor.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& queue);
+  template <typename TimeTraits, typename Allocator>
+  void add_timer_queue(timer_queue<TimeTraits, Allocator>& queue);
 
   // Remove a timer queue from the reactor.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& queue);
+  template <typename TimeTraits, typename Allocator>
+  void remove_timer_queue(timer_queue<TimeTraits, Allocator>& queue);
 
   // Schedule a new operation in the given timer queue to expire at the
   // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
+  template <typename TimeTraits, typename Allocator>
+  void schedule_timer(timer_queue<TimeTraits, Allocator>& queue,
+      const typename TimeTraits::time_type& time,
+      typename timer_queue<TimeTraits, Allocator>::per_timer_data& timer,
+      wait_op* op);
 
   // Cancel the timer operations associated with the given token. Returns the
   // number of operations that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer,
+  template <typename TimeTraits, typename Allocator>
+  std::size_t cancel_timer(timer_queue<TimeTraits, Allocator>& queue,
+      typename timer_queue<TimeTraits, Allocator>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
   // Cancel the timer operations associated with the given key.
-  template <typename Time_Traits>
-  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data* timer,
+  template <typename TimeTraits, typename Allocator>
+  void cancel_timer_by_key(timer_queue<TimeTraits, Allocator>& queue,
+      typename timer_queue<TimeTraits, Allocator>::per_timer_data* timer,
       void* cancellation_key);
 
   // Move the timer operations associated with the given timer.
-  template <typename Time_Traits>
-  void move_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& target,
-      typename timer_queue<Time_Traits>::per_timer_data& source);
+  template <typename TimeTraits, typename Allocator>
+  void move_timer(timer_queue<TimeTraits, Allocator>& queue,
+      typename timer_queue<TimeTraits, Allocator>::per_timer_data& target,
+      typename timer_queue<TimeTraits, Allocator>::per_timer_data& source);
 
   // Run /dev/poll once until interrupted or events are ready to be dispatched.
   ASIO_DECL void run(long usec, op_queue<operation>& ops);

asio/include/asio/detail/epoll_reactor.hpp

@@ -169,38 +169,39 @@ class epoll_reactor
       per_descriptor_data& descriptor_data);
 
   // Add a new timer queue to the reactor.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
+  template <typename TimeTraits, typename Allocator>
+  void add_timer_queue(timer_queue<TimeTraits, Allocator>& timer_queue);
 
   // Remove a timer queue from the reactor.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
+  template <typename TimeTraits, typename Allocator>
+  void remove_timer_queue(timer_queue<TimeTraits, Allocator>& timer_queue);
 
   // Schedule a new operation in the given timer queue to expire at the
   // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
+  template <typename TimeTraits, typename Allocator>
+  void schedule_timer(timer_queue<TimeTraits, Allocator>& queue,
+      const typename TimeTraits::time_type& time,
+      typename timer_queue<TimeTraits, Allocator>::per_timer_data& timer,
+      wait_op* op);
 
   // Cancel the timer operations associated with the given token. Returns the
   // number of operations that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer,
+  template <typename TimeTraits, typename Allocator>
+  std::size_t cancel_timer(timer_queue<TimeTraits, Allocator>& queue,
+      typename timer_queue<TimeTraits, Allocator>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
   // Cancel the timer operations associated with the given key.
-  template <typename Time_Traits>
-  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data* timer,
+  template <typename TimeTraits, typename Allocator>
+  void cancel_timer_by_key(timer_queue<TimeTraits, Allocator>& queue,
+      typename timer_queue<TimeTraits, Allocator>::per_timer_data* timer,
       void* cancellation_key);
 
   // Move the timer operations associated with the given timer.
-  template <typename Time_Traits>
-  void move_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& target,
-      typename timer_queue<Time_Traits>::per_timer_data& source);
+  template <typename TimeTraits, typename Allocator>
+  void move_timer(timer_queue<TimeTraits, Allocator>& queue,
+      typename timer_queue<TimeTraits, Allocator>::per_timer_data& target,
+      typename timer_queue<TimeTraits, Allocator>::per_timer_data& source);
 
   // Run epoll once until interrupted or events are ready to be dispatched.
   ASIO_DECL void run(long usec, op_queue<operation>& ops);

asio/include/asio/detail/impl/dev_poll_reactor.hpp

@@ -32,22 +32,26 @@ inline void dev_poll_reactor::post_immediate_completion(
   scheduler_.post_immediate_completion(op, is_continuation);
 }
 
-template <typename Time_Traits>
-void dev_poll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
+template <typename TimeTraits, typename Allocator>
+void dev_poll_reactor::add_timer_queue(
+    timer_queue<TimeTraits, Allocator>& queue)
 {
   do_add_timer_queue(queue);
 }
 
-template <typename Time_Traits>
-void dev_poll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
+template <typename TimeTraits, typename Allocator>
+void dev_poll_reactor::remove_timer_queue(
+    timer_queue<TimeTraits, Allocator>& queue)
 {
   do_remove_timer_queue(queue);
 }
 
-template <typename Time_Traits>
-void dev_poll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
+template <typename TimeTraits, typename Allocator>
+void dev_poll_reactor::schedule_timer(
+    timer_queue<TimeTraits, Allocator>& queue,
+    const typename TimeTraits::time_type& time,
+    typename timer_queue<TimeTraits, Allocator>::per_timer_data& timer,
+    wait_op* op)
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
 
@@ -63,9 +67,10 @@ void dev_poll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
     interrupter_.interrupt();
 }
 
-template <typename Time_Traits>
-std::size_t dev_poll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
+template <typename TimeTraits, typename Allocator>
+std::size_t dev_poll_reactor::cancel_timer(
+    timer_queue<TimeTraits, Allocator>& queue,
+    typename timer_queue<TimeTraits, Allocator>::per_timer_data& timer,
     std::size_t max_cancelled)
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
@@ -76,9 +81,10 @@ std::size_t dev_poll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
   return n;
 }
 
-template <typename Time_Traits>
-void dev_poll_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data* timer,
+template <typename TimeTraits, typename Allocator>
+void dev_poll_reactor::cancel_timer_by_key(
+    timer_queue<TimeTraits, Allocator>& queue,
+    typename timer_queue<TimeTraits, Allocator>::per_timer_data* timer,
     void* cancellation_key)
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
@@ -88,10 +94,10 @@ void dev_poll_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
   scheduler_.post_deferred_completions(ops);
 }
 
-template <typename Time_Traits>
-void dev_poll_reactor::move_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& target,
-    typename timer_queue<Time_Traits>::per_timer_data& source)
+template <typename TimeTraits, typename Allocator>
+void dev_poll_reactor::move_timer(timer_queue<TimeTraits, Allocator>& queue,
+    typename timer_queue<TimeTraits, Allocator>::per_timer_data& target,
+    typename timer_queue<TimeTraits, Allocator>::per_timer_data& source)
 {
   asio::detail::mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;

asio/include/asio/detail/impl/epoll_reactor.hpp

@@ -30,22 +30,25 @@ inline void epoll_reactor::post_immediate_completion(
   scheduler_.post_immediate_completion(op, is_continuation);
 }
 
-template <typename Time_Traits>
-void epoll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
+template <typename TimeTraits, typename Allocator>
+void epoll_reactor::add_timer_queue(
+    timer_queue<TimeTraits, Allocator>& queue)
 {
   do_add_timer_queue(queue);
 }
 
-template <typename Time_Traits>
-void epoll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
+template <typename TimeTraits, typename Allocator>
+void epoll_reactor::remove_timer_queue(
+    timer_queue<TimeTraits, Allocator>& queue)
 {
   do_remove_timer_queue(queue);
 }
 
-template <typename Time_Traits>
-void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
+template <typename TimeTraits, typename Allocator>
+void epoll_reactor::schedule_timer(timer_queue<TimeTraits, Allocator>& queue,
+    const typename TimeTraits::time_type& time,
+    typename timer_queue<TimeTraits, Allocator>::per_timer_data& timer,
+    wait_op* op)
 {
   mutex::scoped_lock lock(mutex_);
 
@@ -61,9 +64,10 @@ void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
     update_timeout();
 }
 
-template <typename Time_Traits>
-std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
+template <typename TimeTraits, typename Allocator>
+std::size_t epoll_reactor::cancel_timer(
+    timer_queue<TimeTraits, Allocator>& queue,
+    typename timer_queue<TimeTraits, Allocator>::per_timer_data& timer,
     std::size_t max_cancelled)
 {
   mutex::scoped_lock lock(mutex_);
@@ -74,9 +78,10 @@ std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
   return n;
 }
 
-template <typename Time_Traits>
-void epoll_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data* timer,
+template <typename TimeTraits, typename Allocator>
+void epoll_reactor::cancel_timer_by_key(
+    timer_queue<TimeTraits, Allocator>& queue,
+    typename timer_queue<TimeTraits, Allocator>::per_timer_data* timer,
     void* cancellation_key)
 {
   mutex::scoped_lock lock(mutex_);
@@ -86,10 +91,10 @@ void epoll_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
   scheduler_.post_deferred_completions(ops);
 }
 
-template <typename Time_Traits>
-void epoll_reactor::move_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& target,
-    typename timer_queue<Time_Traits>::per_timer_data& source)
+template <typename TimeTraits, typename Allocator>
+void epoll_reactor::move_timer(timer_queue<TimeTraits, Allocator>& queue,
+    typename timer_queue<TimeTraits, Allocator>::per_timer_data& target,
+    typename timer_queue<TimeTraits, Allocator>::per_timer_data& source)
 {
   mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;