[Boost-commit] svn:boost r63577 - in trunk/boost/asio/detail: . impl

Subject: [Boost-commit] svn:boost r63577 - in trunk/boost/asio/detail: . impl
From: chris_at_[hidden]
Date: 2010-07-04 03:37:44

Author: chris_kohlhoff
Date: 2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
New Revision: 63577
URL: http://svn.boost.org/trac/boost/changeset/63577

Log:
Eliminate unnecessary uses of hash_map.

Added:
   trunk/boost/asio/detail/object_pool.hpp   (contents, props changed)
Text files modified: 
   trunk/boost/asio/detail/deadline_timer_service.hpp   |     5                                         
   trunk/boost/asio/detail/dev_poll_reactor.hpp         |     6                                         
   trunk/boost/asio/detail/epoll_reactor.hpp            |    31 ++---                                   
   trunk/boost/asio/detail/impl/dev_poll_reactor.hpp    |    21 ++-                                     
   trunk/boost/asio/detail/impl/dev_poll_reactor.ipp    |     3                                         
   trunk/boost/asio/detail/impl/epoll_reactor.hpp       |    23 ++-                                     
   trunk/boost/asio/detail/impl/epoll_reactor.ipp       |    67 ++++++++-----                           
   trunk/boost/asio/detail/impl/kqueue_reactor.hpp      |    23 ++-                                     
   trunk/boost/asio/detail/impl/kqueue_reactor.ipp      |    67 ++++++++-----                           
   trunk/boost/asio/detail/impl/select_reactor.hpp      |    23 ++-                                     
   trunk/boost/asio/detail/impl/select_reactor.ipp      |    14 +-                                      
   trunk/boost/asio/detail/impl/timer_queue.ipp         |     8                                         
   trunk/boost/asio/detail/impl/win_iocp_io_service.hpp |    14 +-                                      
   trunk/boost/asio/detail/kqueue_reactor.hpp           |    27 ++---                                   
   trunk/boost/asio/detail/select_reactor.hpp           |     6                                         
   trunk/boost/asio/detail/timer_queue.hpp              |   200 +++++++++++++++++++++++---------------- 
   trunk/boost/asio/detail/win_iocp_io_service.hpp      |     8 +                                       
   17 files changed, 321 insertions(+), 225 deletions(-)

Modified: trunk/boost/asio/detail/deadline_timer_service.hpp
==============================================================================
--- trunk/boost/asio/detail/deadline_timer_service.hpp	(original)
+++ trunk/boost/asio/detail/deadline_timer_service.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -56,6 +56,7 @@
   {
     time_type expiry;
     bool might_have_pending_waits;
+    typename timer_queue<Time_Traits>::per_timer_data timer_data;
   };
 
   // Constructor.
@@ -99,7 +100,7 @@
       ec = boost::system::error_code();
       return 0;
     }
-    std::size_t count = scheduler_.cancel_timer(timer_queue_, &impl);
+    std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
     impl.might_have_pending_waits = false;
     ec = boost::system::error_code();
     return count;
@@ -166,7 +167,7 @@
 
     impl.might_have_pending_waits = true;
 
-    scheduler_.schedule_timer(timer_queue_, impl.expiry, p.p, &impl);
+    scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
     p.v = p.p = 0;
   }
 

Modified: trunk/boost/asio/detail/dev_poll_reactor.hpp
==============================================================================
--- trunk/boost/asio/detail/dev_poll_reactor.hpp	(original)
+++ trunk/boost/asio/detail/dev_poll_reactor.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -103,12 +103,14 @@
   // specified absolute time.
   template <typename Time_Traits>
   void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time, timer_op* op, void* token);
+      const typename Time_Traits::time_type& time,
+      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_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, void* token);
+  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& timer);
 
   // Run /dev/poll once until interrupted or events are ready to be dispatched.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);

Modified: trunk/boost/asio/detail/epoll_reactor.hpp
==============================================================================
--- trunk/boost/asio/detail/epoll_reactor.hpp	(original)
+++ trunk/boost/asio/detail/epoll_reactor.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -21,8 +21,8 @@
 
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/epoll_reactor_fwd.hpp>
-#include <boost/asio/detail/hash_map.hpp>
 #include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/object_pool.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
@@ -46,15 +46,15 @@
     connect_op = 1, except_op = 2, max_ops = 3 };
 
   // Per-descriptor queues.
-  struct descriptor_state
+  class descriptor_state
   {
-    descriptor_state() {}
-    descriptor_state(const descriptor_state&) {}
-    void operator=(const descriptor_state&) {}
-
+    friend class epoll_reactor;
+    friend class object_pool_access;
     mutex mutex_;
     op_queue<reactor_op> op_queue_[max_ops];
     bool shutdown_;
+    descriptor_state* next_;
+    descriptor_state* prev_;
   };
 
   // Per-descriptor data.
@@ -111,13 +111,15 @@
   // 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>& timer_queue,
-      const typename Time_Traits::time_type& time, timer_op* op, void* token);
+  void schedule_timer(timer_queue<Time_Traits>& queue,
+      const typename Time_Traits::time_type& time,
+      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_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>& timer_queue, void* token);
+  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& timer);
 
   // Run epoll once until interrupted or events are ready to be dispatched.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);
@@ -177,15 +179,8 @@
   // Mutex to protect access to the registered descriptors.
   mutex registered_descriptors_mutex_;
 
-  // Keep track of all registered descriptors. This code relies on the fact that
-  // the hash_map implementation pools deleted nodes, meaning that we can assume
-  // our descriptor_state pointer remains valid even after the entry is removed.
-  // Technically this is not true for C++98, as that standard says that spliced
-  // elements in a list are invalidated. However, C++0x fixes this shortcoming
-  // so we'll just assume that C++98 std::list implementations will do the right
-  // thing anyway.
-  typedef detail::hash_map<socket_type, descriptor_state> descriptor_map;
-  descriptor_map registered_descriptors_;
+  // Keep track of all registered descriptors.
+  object_pool<descriptor_state> registered_descriptors_;
 };
 
 } // namespace detail

Modified: trunk/boost/asio/detail/impl/dev_poll_reactor.hpp
==============================================================================
--- trunk/boost/asio/detail/impl/dev_poll_reactor.hpp	(original)
+++ trunk/boost/asio/detail/impl/dev_poll_reactor.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -39,25 +39,30 @@
 
 template <typename Time_Traits>
 void dev_poll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time, timer_op* op, void* token)
+    const typename Time_Traits::time_type& time,
+    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  if (!shutdown_)
+
+  if (shutdown_)
   {
-    bool earliest = queue.enqueue_timer(time, op, token);
-    io_service_.work_started();
-    if (earliest)
-      interrupter_.interrupt();
+    io_service_.post_immediate_completion(op);
+    return;
   }
+
+  bool earliest = queue.enqueue_timer(time, timer, op);
+  io_service_.work_started();
+  if (earliest)
+    interrupter_.interrupt();
 }
 
 template <typename Time_Traits>
 std::size_t dev_poll_reactor::cancel_timer(
-    timer_queue<Time_Traits>& queue, void* token)
+    typename timer_queue<Time_Traits>::per_timer_data& timer)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(token, ops);
+  std::size_t n = queue.cancel_timer(timer, ops);
   lock.unlock();
   io_service_.post_deferred_completions(ops);
   return n;

Modified: trunk/boost/asio/detail/impl/dev_poll_reactor.ipp
==============================================================================
--- trunk/boost/asio/detail/impl/dev_poll_reactor.ipp	(original)
+++ trunk/boost/asio/detail/impl/dev_poll_reactor.ipp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -82,7 +82,10 @@
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
+  {
+    post_immediate_completion(op);
     return;
+  }
 
   if (allow_speculative)
   {

Modified: trunk/boost/asio/detail/impl/epoll_reactor.hpp
==============================================================================
--- trunk/boost/asio/detail/impl/epoll_reactor.hpp	(original)
+++ trunk/boost/asio/detail/impl/epoll_reactor.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -37,25 +37,30 @@
 
 template <typename Time_Traits>
 void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time, timer_op* op, void* token)
+    const typename Time_Traits::time_type& time,
+    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
 {
   mutex::scoped_lock lock(mutex_);
-  if (!shutdown_)
+
+  if (shutdown_)
   {
-    bool earliest = queue.enqueue_timer(time, op, token);
-    io_service_.work_started();
-    if (earliest)
-      update_timeout();
+    io_service_.post_immediate_completion(op);
+    return;
   }
+
+  bool earliest = queue.enqueue_timer(time, timer, op);
+  io_service_.work_started();
+  if (earliest)
+    update_timeout();
 }
 
 template <typename Time_Traits>
-std::size_t epoll_reactor::cancel_timer(
-    timer_queue<Time_Traits>& queue, void* token)
+std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& timer)
 {
   mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(token, ops);
+  std::size_t n = queue.cancel_timer(timer, ops);
   lock.unlock();
   io_service_.post_deferred_completions(ops);
   return n;

Modified: trunk/boost/asio/detail/impl/epoll_reactor.ipp
==============================================================================
--- trunk/boost/asio/detail/impl/epoll_reactor.ipp	(original)
+++ trunk/boost/asio/detail/impl/epoll_reactor.ipp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -79,14 +79,12 @@
 
   op_queue<operation> ops;
 
-  descriptor_map::iterator iter = registered_descriptors_.begin();
-  descriptor_map::iterator end = registered_descriptors_.end();
-  while (iter != end)
+  while (descriptor_state* state = registered_descriptors_.first())
   {
     for (int i = 0; i < max_ops; ++i)
-      ops.push(iter->second.op_queue_[i]);
-    iter->second.shutdown_ = true;
-    ++iter;
+      ops.push(state->op_queue_[i]);
+    state->shutdown_ = true;
+    registered_descriptors_.free(state);
   }
 
   timer_queues_.get_all_timers(ops);
@@ -102,10 +100,7 @@
 {
   mutex::scoped_lock lock(registered_descriptors_mutex_);
 
-  descriptor_map::iterator new_entry = registered_descriptors_.insert(
-        std::make_pair(descriptor, descriptor_state())).first;
-  descriptor_data = &new_entry->second;
-
+  descriptor_data = registered_descriptors_.alloc();
   descriptor_data->shutdown_ = false;
 
   lock.unlock();
@@ -124,9 +119,20 @@
     epoll_reactor::per_descriptor_data& descriptor_data,
     reactor_op* op, bool allow_speculative)
 {
+  if (!descriptor_data)
+  {
+    op->ec_ = boost::asio::error::bad_descriptor;
+    post_immediate_completion(op);
+    return;
+  }
+
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
   if (descriptor_data->shutdown_)
+  {
+    post_immediate_completion(op);
     return;
+  }
 
   if (descriptor_data->op_queue_[op_type].empty())
   {
@@ -158,6 +164,9 @@
 void epoll_reactor::cancel_ops(socket_type,
     epoll_reactor::per_descriptor_data& descriptor_data)
 {
+  if (!descriptor_data)
+    return;
+
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
   op_queue<operation> ops;
@@ -179,31 +188,39 @@
 void epoll_reactor::close_descriptor(socket_type descriptor,
     epoll_reactor::per_descriptor_data& descriptor_data)
 {
+  if (!descriptor_data)
+    return;
+
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
   mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
 
-  // Remove the descriptor from the set of known descriptors. The descriptor
-  // will be automatically removed from the epoll set when it is closed.
-  descriptor_data->shutdown_ = true;
-
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
+  if (!descriptor_data->shutdown_)
   {
-    while (reactor_op* op = descriptor_data->op_queue_[i].front())
+    // Remove the descriptor from the set of known descriptors. The descriptor
+    // will be automatically removed from the epoll set when it is closed.
+
+    op_queue<operation> ops;
+    for (int i = 0; i < max_ops; ++i)
     {
-      op->ec_ = boost::asio::error::operation_aborted;
-      descriptor_data->op_queue_[i].pop();
-      ops.push(op);
+      while (reactor_op* op = descriptor_data->op_queue_[i].front())
+      {
+        op->ec_ = boost::asio::error::operation_aborted;
+        descriptor_data->op_queue_[i].pop();
+        ops.push(op);
+      }
     }
-  }
 
-  descriptor_lock.unlock();
+    descriptor_data->shutdown_ = true;
 
-  registered_descriptors_.erase(descriptor);
+    descriptor_lock.unlock();
 
-  descriptors_lock.unlock();
+    registered_descriptors_.free(descriptor_data);
+    descriptor_data = 0;
 
-  io_service_.post_deferred_completions(ops);
+    descriptors_lock.unlock();
+
+    io_service_.post_deferred_completions(ops);
+  }
 }
 
 void epoll_reactor::run(bool block, op_queue<operation>& ops)

Modified: trunk/boost/asio/detail/impl/kqueue_reactor.hpp
==============================================================================
--- trunk/boost/asio/detail/impl/kqueue_reactor.hpp	(original)
+++ trunk/boost/asio/detail/impl/kqueue_reactor.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -41,25 +41,30 @@
 
 template <typename Time_Traits>
 void kqueue_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time, timer_op* op, void* token)
+    const typename Time_Traits::time_type& time,
+    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  if (!shutdown_)
+
+  if (shutdown_)
   {
-    bool earliest = queue.enqueue_timer(time, op, token);
-    io_service_.work_started();
-    if (earliest)
-      interrupter_.interrupt();
+    io_service_.post_immediate_completion(op);
+    return;
   }
+
+  bool earliest = queue.enqueue_timer(time, timer, op);
+  io_service_.work_started();
+  if (earliest)
+    interrupter_.interrupt();
 }
 
 template <typename Time_Traits>
-std::size_t kqueue_reactor::cancel_timer(
-    timer_queue<Time_Traits>& queue, void* token)
+std::size_t kqueue_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& timer)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(token, ops);
+  std::size_t n = queue.cancel_timer(timer, ops);
   lock.unlock();
   io_service_.post_deferred_completions(ops);
   return n;

Modified: trunk/boost/asio/detail/impl/kqueue_reactor.ipp
==============================================================================
--- trunk/boost/asio/detail/impl/kqueue_reactor.ipp	(original)
+++ trunk/boost/asio/detail/impl/kqueue_reactor.ipp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -57,14 +57,12 @@
 
   op_queue<operation> ops;
 
-  descriptor_map::iterator iter = registered_descriptors_.begin();
-  descriptor_map::iterator end = registered_descriptors_.end();
-  while (iter != end)
+  while (descriptor_state* state = registered_descriptors_.first())
   {
     for (int i = 0; i < max_ops; ++i)
-      ops.push(iter->second.op_queue_[i]);
-    iter->second.shutdown_ = true;
-    ++iter;
+      ops.push(state->op_queue_[i]);
+    state->shutdown_ = true;
+    registered_descriptors_.free(state);
   }
 
   timer_queues_.get_all_timers(ops);
@@ -80,10 +78,7 @@
 {
   mutex::scoped_lock lock(registered_descriptors_mutex_);
 
-  descriptor_map::iterator new_entry = registered_descriptors_.insert(
-        std::make_pair(descriptor, descriptor_state())).first;
-  descriptor_data = &new_entry->second;
-
+  descriptor_data = registered_descriptors_.alloc();
   descriptor_data->shutdown_ = false;
 
   return 0;
@@ -93,9 +88,20 @@
     kqueue_reactor::per_descriptor_data& descriptor_data,
     reactor_op* op, bool allow_speculative)
 {
+  if (!descriptor_data)
+  {
+    op->ec_ = boost::asio::error::bad_descriptor;
+    post_immediate_completion(op);
+    return;
+  }
+
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
   if (descriptor_data->shutdown_)
+  {
+    post_immediate_completion(op);
     return;
+  }
 
   bool first = descriptor_data->op_queue_[op_type].empty();
   if (first)
@@ -151,6 +157,9 @@
 void kqueue_reactor::cancel_ops(socket_type,
     kqueue_reactor::per_descriptor_data& descriptor_data)
 {
+  if (!descriptor_data)
+    return;
+
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
   op_queue<operation> ops;
@@ -172,31 +181,39 @@
 void kqueue_reactor::close_descriptor(socket_type descriptor,
     kqueue_reactor::per_descriptor_data& descriptor_data)
 {
+  if (!descriptor_data)
+    return;
+
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
   mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
 
-  // Remove the descriptor from the set of known descriptors. The descriptor
-  // will be automatically removed from the kqueue set when it is closed.
-  descriptor_data->shutdown_ = true;
-
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
+  if (!descriptor_data->shutdown_)
   {
-    while (reactor_op* op = descriptor_data->op_queue_[i].front())
+    // Remove the descriptor from the set of known descriptors. The descriptor
+    // will be automatically removed from the kqueue set when it is closed.
+
+    op_queue<operation> ops;
+    for (int i = 0; i < max_ops; ++i)
     {
-      op->ec_ = boost::asio::error::operation_aborted;
-      descriptor_data->op_queue_[i].pop();
-      ops.push(op);
+      while (reactor_op* op = descriptor_data->op_queue_[i].front())
+      {
+        op->ec_ = boost::asio::error::operation_aborted;
+        descriptor_data->op_queue_[i].pop();
+        ops.push(op);
+      }
     }
-  }
 
-  descriptor_lock.unlock();
+    descriptor_data->shutdown_ = true;
 
-  registered_descriptors_.erase(descriptor);
+    descriptor_lock.unlock();
 
-  descriptors_lock.unlock();
+    registered_descriptors_.free(descriptor_data);
+    descriptor_data = 0;
 
-  io_service_.post_deferred_completions(ops);
+    descriptors_lock.unlock();
+
+    io_service_.post_deferred_completions(ops);
+  }
 }
 
 void kqueue_reactor::run(bool block, op_queue<operation>& ops)

Modified: trunk/boost/asio/detail/impl/select_reactor.hpp
==============================================================================
--- trunk/boost/asio/detail/impl/select_reactor.hpp	(original)
+++ trunk/boost/asio/detail/impl/select_reactor.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -43,25 +43,30 @@
 
 template <typename Time_Traits>
 void select_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time, timer_op* op, void* token)
+    const typename Time_Traits::time_type& time,
+    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  if (!shutdown_)
+
+  if (shutdown_)
   {
-    bool earliest = queue.enqueue_timer(time, op, token);
-    io_service_.work_started();
-    if (earliest)
-      interrupter_.interrupt();
+    io_service_.post_immediate_completion(op);
+    return;
   }
+
+  bool earliest = queue.enqueue_timer(time, timer, op);
+  io_service_.work_started();
+  if (earliest)
+    interrupter_.interrupt();
 }
 
 template <typename Time_Traits>
-std::size_t select_reactor::cancel_timer(
-    timer_queue<Time_Traits>& queue, void* token)
+std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& timer)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(token, ops);
+  std::size_t n = queue.cancel_timer(timer, ops);
   lock.unlock();
   io_service_.post_deferred_completions(ops);
   return n;

Modified: trunk/boost/asio/detail/impl/select_reactor.ipp
==============================================================================
--- trunk/boost/asio/detail/impl/select_reactor.ipp	(original)
+++ trunk/boost/asio/detail/impl/select_reactor.ipp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -99,13 +99,17 @@
     select_reactor::per_descriptor_data&, reactor_op* op, bool)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  if (!shutdown_)
+
+  if (shutdown_)
   {
-    bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
-    io_service_.work_started();
-    if (first)
-      interrupter_.interrupt();
+    post_immediate_completion(op);
+    return;
   }
+
+  bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
+  io_service_.work_started();
+  if (first)
+    interrupter_.interrupt();
 }
 
 void select_reactor::cancel_ops(socket_type descriptor,

Modified: trunk/boost/asio/detail/impl/timer_queue.ipp
==============================================================================
--- trunk/boost/asio/detail/impl/timer_queue.ipp	(original)
+++ trunk/boost/asio/detail/impl/timer_queue.ipp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -36,9 +36,9 @@
 }
 
 bool timer_queue<time_traits<boost::posix_time::ptime> >::enqueue_timer(
-    const time_type& time, timer_op* op, void* token)
+    const time_type& time, per_timer_data& timer, timer_op* op)
 {
-  return impl_.enqueue_timer(time, op, token);
+  return impl_.enqueue_timer(time, timer, op);
 }
 
 bool timer_queue<time_traits<boost::posix_time::ptime> >::empty() const
@@ -71,9 +71,9 @@
 }
 
 std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer(
-    void* timer_token, op_queue<operation>& ops)
+    per_timer_data& timer, op_queue<operation>& ops)
 {
-  return impl_.cancel_timer(timer_token, ops);
+  return impl_.cancel_timer(timer, ops);
 }
 
 } // namespace detail

Modified: trunk/boost/asio/detail/impl/win_iocp_io_service.hpp
==============================================================================
--- trunk/boost/asio/detail/impl/win_iocp_io_service.hpp	(original)
+++ trunk/boost/asio/detail/impl/win_iocp_io_service.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -73,23 +73,27 @@
 
 template <typename Time_Traits>
 void win_iocp_io_service::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time, timer_op* op, void* token)
+    const typename Time_Traits::time_type& time,
+    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
 {
   // If the service has been shut down we silently discard the timer.
   if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
+  {
+    post_immediate_completion(op);
     return;
+  }
 
   mutex::scoped_lock lock(dispatch_mutex_);
 
-  bool earliest = queue.enqueue_timer(time, op, token);
+  bool earliest = queue.enqueue_timer(time, timer, op);
   work_started();
   if (earliest)
     update_timeout();
 }
 
 template <typename Time_Traits>
-std::size_t win_iocp_io_service::cancel_timer(
-    timer_queue<Time_Traits>& queue, void* token)
+std::size_t win_iocp_io_service::cancel_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& timer)
 {
   // If the service has been shut down we silently ignore the cancellation.
   if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
@@ -97,7 +101,7 @@
 
   mutex::scoped_lock lock(dispatch_mutex_);
   op_queue<win_iocp_operation> ops;
-  std::size_t n = queue.cancel_timer(token, ops);
+  std::size_t n = queue.cancel_timer(timer, ops);
   post_deferred_completions(ops);
   return n;
 }

Modified: trunk/boost/asio/detail/kqueue_reactor.hpp
==============================================================================
--- trunk/boost/asio/detail/kqueue_reactor.hpp	(original)
+++ trunk/boost/asio/detail/kqueue_reactor.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -24,9 +24,9 @@
 #include <sys/types.h>
 #include <sys/event.h>
 #include <sys/time.h>
-#include <boost/asio/detail/hash_map.hpp>
 #include <boost/asio/detail/kqueue_reactor_fwd.hpp>
 #include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/object_pool.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
@@ -59,13 +59,13 @@
   // Per-descriptor queues.
   struct descriptor_state
   {
-    descriptor_state() {}
-    descriptor_state(const descriptor_state&) {}
-    void operator=(const descriptor_state&) {}
-
+    friend class kqueue_reactor;
+    friend class object_pool_access;
     mutex mutex_;
     op_queue<reactor_op> op_queue_[max_ops];
     bool shutdown_;
+    descriptor_state* next_;
+    descriptor_state* prev_;
   };
 
   // Per-descriptor data.
@@ -123,12 +123,14 @@
   // specified absolute time.
   template <typename Time_Traits>
   void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time, timer_op* op, void* token);
+      const typename Time_Traits::time_type& time,
+      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_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, void* token);
+  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& timer);
 
   // Run the kqueue loop.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);
@@ -171,15 +173,8 @@
   // Mutex to protect access to the registered descriptors.
   mutex registered_descriptors_mutex_;
 
-  // Keep track of all registered descriptors. This code relies on the fact that
-  // the hash_map implementation pools deleted nodes, meaning that we can assume
-  // our descriptor_state pointer remains valid even after the entry is removed.
-  // Technically this is not true for C++98, as that standard says that spliced
-  // elements in a list are invalidated. However, C++0x fixes this shortcoming
-  // so we'll just assume that C++98 std::list implementations will do the right
-  // thing anyway.
-  typedef detail::hash_map<socket_type, descriptor_state> descriptor_map;
-  descriptor_map registered_descriptors_;
+  // Keep track of all registered descriptors.
+  object_pool<descriptor_state> registered_descriptors_;
 };
 
 } // namespace detail

Added: trunk/boost/asio/detail/object_pool.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/asio/detail/object_pool.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -0,0 +1,148 @@
+//
+// detail/object_pool.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2010 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)
+//
+
+#ifndef BOOST_ASIO_DETAIL_OBJECT_POOL_HPP
+#define BOOST_ASIO_DETAIL_OBJECT_POOL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/noncopyable.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Object>
+class object_pool;
+
+class object_pool_access
+{
+public:
+  template <typename Object>
+  static Object* create()
+  {
+    return new Object;
+  }
+
+  template <typename Object>
+  static void destroy(Object* o)
+  {
+    delete o;
+  }
+
+  template <typename Object>
+  static Object*& next(Object* o)
+  {
+    return o->next_;
+  }
+
+  template <typename Object>
+  static Object*& prev(Object* o)
+  {
+    return o->prev_;
+  }
+};
+
+template <typename Object>
+class object_pool
+  : private noncopyable
+{
+public:
+  // Constructor.
+  object_pool()
+    : live_list_(0),
+      free_list_(0)
+  {
+  }
+
+  // Destructor destroys all objects.
+  ~object_pool()
+  {
+    destroy_list(live_list_);
+    destroy_list(free_list_);
+  }
+
+  // Get the object at the start of the live list.
+  Object* first()
+  {
+    return live_list_;
+  }
+
+  // Allocate a new object.
+  Object* alloc()
+  {
+    Object* o = free_list_;
+    if (o)
+      free_list_ = object_pool_access::next(free_list_);
+    else
+      o = object_pool_access::create<Object>();
+
+    object_pool_access::next(o) = live_list_;
+    object_pool_access::prev(o) = 0;
+    if (live_list_)
+      object_pool_access::prev(live_list_) = o;
+    live_list_ = o;
+
+    return o;
+  }
+
+  // Free an object. Moves it to the free list. No destructors are run.
+  void free(Object* o)
+  {
+    if (live_list_ == o)
+      live_list_ = object_pool_access::next(o);
+
+    if (object_pool_access::prev(o))
+    {
+      object_pool_access::next(object_pool_access::prev(o))
+        = object_pool_access::next(o);
+    }
+
+    if (object_pool_access::next(o))
+    {
+      object_pool_access::prev(object_pool_access::next(o))
+        = object_pool_access::prev(o);
+    }
+
+    object_pool_access::next(o) = free_list_;
+    object_pool_access::prev(o) = 0;
+    free_list_ = o;
+  }
+
+private:
+  // Helper function to destroy all elements in a list.
+  void destroy_list(Object* list)
+  {
+    while (list)
+    {
+      Object* o = list;
+      list = object_pool_access::next(o);
+      object_pool_access::destroy(o);
+    }
+  }
+
+  // The list of live objects.
+  Object* live_list_;
+
+  // The free list.
+  Object* free_list_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_OBJECT_POOL_HPP

Modified: trunk/boost/asio/detail/select_reactor.hpp
==============================================================================
--- trunk/boost/asio/detail/select_reactor.hpp	(original)
+++ trunk/boost/asio/detail/select_reactor.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -112,12 +112,14 @@
   // specified absolute time.
   template <typename Time_Traits>
   void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time, timer_op* op, void* token);
+      const typename Time_Traits::time_type& time,
+      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_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, void* token);
+  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& timer);
 
   // Run select once until interrupted or events are ready to be dispatched.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);

Modified: trunk/boost/asio/detail/timer_queue.hpp
==============================================================================
--- trunk/boost/asio/detail/timer_queue.hpp	(original)
+++ trunk/boost/asio/detail/timer_queue.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -17,11 +17,9 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
-#include <memory>
 #include <vector>
 #include <boost/config.hpp>
 #include <boost/limits.hpp>
-#include <boost/asio/detail/hash_map.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/timer_op.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
@@ -49,6 +47,26 @@
   // The duration type.
   typedef typename Time_Traits::duration_type duration_type;
 
+  // Per-timer data.
+  class per_timer_data
+  {
+  public:
+    per_timer_data() : next_(0), prev_(0) {}
+
+  private:
+    friend class timer_queue;
+
+    // The operations waiting on the timer.
+    op_queue<timer_op> op_queue_;
+
+    // The index of the timer in the heap.
+    std::size_t heap_index_;
+
+    // Pointers to adjacent timers in a linked list.
+    per_timer_data* next_;
+    per_timer_data* prev_;
+  };
+
   // Constructor.
   timer_queue()
     : timers_(),
@@ -59,35 +77,44 @@
   // Add a new timer to the queue. Returns true if this is the timer that is
   // earliest in the queue, in which case the reactor's event demultiplexing
   // function call may need to be interrupted and restarted.
-  bool enqueue_timer(const time_type& time, timer_op* op, void* token)
+  bool enqueue_timer(const time_type& time, per_timer_data& timer, timer_op* op)
   {
     // Ensure that there is space for the timer in the heap. We reserve here so
     // that the push_back below will not throw due to a reallocation failure.
     heap_.reserve(heap_.size() + 1);
 
-    // Insert the new timer into the hash.
-    typedef typename hash_map<void*, timer>::iterator iterator;
-    typedef typename hash_map<void*, timer>::value_type value_type;
-    std::pair<iterator, bool> result =
-      timers_.insert(value_type(token, timer()));
-    result.first->second.op_queue_.push(op);
-    if (result.second)
+    timer.op_queue_.push(op);
+    if (timer.prev_ == 0 && &timer != timers_)
     {
+      // Insert the new timer into the linked list of active timers.
+      timer.next_ = timers_;
+      timer.prev_ = 0;
+      if (timers_)
+        timers_->prev_ = &timer;
+      timers_ = &timer;
+
       // Put the new timer at the correct position in the heap.
-      result.first->second.time_ = time;
-      result.first->second.heap_index_ = heap_.size();
-      result.first->second.token_ = token;
-      heap_.push_back(&result.first->second);
-      up_heap(heap_.size() - 1);
+      if (this->is_positive_infinity(time))
+      {
+        timer.heap_index_ = (std::numeric_limits<std::size_t>::max)();
+        return false; // No need to interrupt reactor as timer never expires.
+      }
+      else
+      {
+        timer.heap_index_ = heap_.size();
+        heap_entry entry = { time, &timer };
+        heap_.push_back(entry);
+        up_heap(heap_.size() - 1);
+      }
     }
 
-    return (heap_[0] == &result.first->second);
+    return (heap_[0].timer_ == &timer);
   }
 
   // Whether there are no timers in the queue.
   virtual bool empty() const
   {
-    return heap_.empty();
+    return timers_ == 0;
   }
 
   // Get the time for the timer that is earliest in the queue.
@@ -97,7 +124,7 @@
       return max_duration;
 
     boost::posix_time::time_duration duration = Time_Traits::to_posix_duration(
-        Time_Traits::subtract(heap_[0]->time_, Time_Traits::now()));
+        Time_Traits::subtract(heap_[0].time_, Time_Traits::now()));
 
     if (duration > boost::posix_time::milliseconds(max_duration))
       duration = boost::posix_time::milliseconds(max_duration);
@@ -116,7 +143,7 @@
       return max_duration;
 
     boost::posix_time::time_duration duration = Time_Traits::to_posix_duration(
-        Time_Traits::subtract(heap_[0]->time_, Time_Traits::now()));
+        Time_Traits::subtract(heap_[0].time_, Time_Traits::now()));
 
     if (duration > boost::posix_time::microseconds(max_duration))
       duration = boost::posix_time::microseconds(max_duration);
@@ -132,77 +159,54 @@
   virtual void get_ready_timers(op_queue<operation>& ops)
   {
     const time_type now = Time_Traits::now();
-    while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0]->time_))
+    while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0].time_))
     {
-      timer* t = heap_[0];
-      ops.push(t->op_queue_);
-      remove_timer(t);
+      per_timer_data* timer = heap_[0].timer_;
+      ops.push(timer->op_queue_);
+      remove_timer(*timer);
     }
   }
 
   // Dequeue all timers.
   virtual void get_all_timers(op_queue<operation>& ops)
   {
-    typename hash_map<void*, timer>::iterator i = timers_.begin();
-    typename hash_map<void*, timer>::iterator end = timers_.end();
-    while (i != end)
+    while (timers_)
     {
-      ops.push(i->second.op_queue_);
-      typename hash_map<void*, timer>::iterator old_i = i++;
-      timers_.erase(old_i);
+      per_timer_data* timer = timers_;
+      timers_ = timers_->next_;
+      ops.push(timer->op_queue_);
+      timer->next_ = 0;
+      timer->prev_ = 0;
     }
 
     heap_.clear();
-    timers_.clear();
   }
 
   // Cancel and dequeue the timers with the given token.
-  std::size_t cancel_timer(void* timer_token, op_queue<operation>& ops)
+  std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops)
   {
     std::size_t num_cancelled = 0;
-    typedef typename hash_map<void*, timer>::iterator iterator;
-    iterator it = timers_.find(timer_token);
-    if (it != timers_.end())
+    if (timer.prev_ != 0 || &timer == timers_)
     {
-      while (timer_op* op = it->second.op_queue_.front())
+      while (timer_op* op = timer.op_queue_.front())
       {
         op->ec_ = boost::asio::error::operation_aborted;
-        it->second.op_queue_.pop();
+        timer.op_queue_.pop();
         ops.push(op);
         ++num_cancelled;
       }
-      remove_timer(&it->second);
+      remove_timer(timer);
     }
     return num_cancelled;
   }
 
 private:
-  // Structure representing a single outstanding timer.
-  struct timer
-  {
-    timer() {}
-    timer(const timer&) {}
-    void operator=(const timer&) {}
-
-    // The time when the timer should fire.
-    time_type time_;
-
-    // The operations waiting on the timer.
-    op_queue<timer_op> op_queue_;
-
-    // The index of the timer in the heap.
-    size_t heap_index_;
-
-    // The token associated with the timer.
-    void* token_;
-  };
-
   // Move the item at the given index up the heap to its correct position.
-  void up_heap(size_t index)
+  void up_heap(std::size_t index)
   {
-    size_t parent = (index - 1) / 2;
+    std::size_t parent = (index - 1) / 2;
     while (index > 0
-        && Time_Traits::less_than(heap_[index]->time_, heap_[parent]->time_))
+        && Time_Traits::less_than(heap_[index].time_, heap_[parent].time_))
     {
       swap_heap(index, parent);
       index = parent;
@@ -211,16 +215,16 @@
   }
 
   // Move the item at the given index down the heap to its correct position.
-  void down_heap(size_t index)
+  void down_heap(std::size_t index)
   {
-    size_t child = index * 2 + 1;
+    std::size_t child = index * 2 + 1;
     while (child < heap_.size())
     {
-      size_t min_child = (child + 1 == heap_.size()
+      std::size_t min_child = (child + 1 == heap_.size()
           || Time_Traits::less_than(
-            heap_[child]->time_, heap_[child + 1]->time_))
+            heap_[child].time_, heap_[child + 1].time_))
         ? child : child + 1;
-      if (Time_Traits::less_than(heap_[index]->time_, heap_[min_child]->time_))
+      if (Time_Traits::less_than(heap_[index].time_, heap_[min_child].time_))
         break;
       swap_heap(index, min_child);
       index = min_child;
@@ -229,20 +233,20 @@
   }
 
   // Swap two entries in the heap.
-  void swap_heap(size_t index1, size_t index2)
+  void swap_heap(std::size_t index1, std::size_t index2)
   {
-    timer* tmp = heap_[index1];
+    heap_entry tmp = heap_[index1];
     heap_[index1] = heap_[index2];
     heap_[index2] = tmp;
-    heap_[index1]->heap_index_ = index1;
-    heap_[index2]->heap_index_ = index2;
+    heap_[index1].timer_->heap_index_ = index1;
+    heap_[index2].timer_->heap_index_ = index2;
   }
 
   // Remove a timer from the heap and list of timers.
-  void remove_timer(timer* t)
+  void remove_timer(per_timer_data& timer)
   {
     // Remove the timer from the heap.
-    size_t index = t->heap_index_;
+    std::size_t index = timer.heap_index_;
     if (!heap_.empty() && index < heap_.size())
     {
       if (index == heap_.size() - 1)
@@ -253,27 +257,53 @@
       {
         swap_heap(index, heap_.size() - 1);
         heap_.pop_back();
-        size_t parent = (index - 1) / 2;
+        std::size_t parent = (index - 1) / 2;
         if (index > 0 && Time_Traits::less_than(
-              heap_[index]->time_, heap_[parent]->time_))
+              heap_[index].time_, heap_[parent].time_))
           up_heap(index);
         else
           down_heap(index);
       }
     }
 
-    // Remove the timer from the hash.
-    typedef typename hash_map<void*, timer>::iterator iterator;
-    iterator it = timers_.find(t->token_);
-    if (it != timers_.end())
-      timers_.erase(it);
+    // Remove the timer from the linked list of active timers.
+    if (timers_ == &timer)
+      timers_ = timer.next_;
+    if (timer.prev_)
+      timer.prev_->next_ = timer.next_;
+    if (timer.next_)
+      timer.next_->prev_= timer.prev_;
+    timer.next_ = 0;
+    timer.prev_ = 0;
+  }
+
+  // Determine if the specified absolute time is positive infinity.
+  template <typename Time_Type>
+  static bool is_positive_infinity(const Time_Type& time)
+  {
+    return false;
+  }
+
+  // Determine if the specified absolute time is positive infinity.
+  static bool is_positive_infinity(const boost::posix_time::ptime& time)
+  {
+    return time == boost::posix_time::pos_infin;
   }
 
-  // A hash of timer token to linked lists of timers.
-  hash_map<void*, timer> timers_;
+  // The head of a linked list of all active timers.
+  per_timer_data* timers_;
+
+  struct heap_entry
+  {
+    // The time when the timer should fire.
+    time_type time_;
+
+    // The associated timer with enqueued operations.
+    per_timer_data* timer_;
+  };
 
   // The heap of timers, with the earliest timer at the front.
-  std::vector<timer*> heap_;
+  std::vector<heap_entry> heap_;
 };
 
 #if !defined(BOOST_ASIO_HEADER_ONLY)
@@ -292,6 +322,10 @@
   // The duration type.
   typedef boost::posix_time::time_duration duration_type;
 
+  // Per-timer data.
+  typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
+    per_timer_data;
+
   // Constructor.
   BOOST_ASIO_DECL timer_queue();
 
@@ -302,7 +336,7 @@
   // earliest in the queue, in which case the reactor's event demultiplexing
   // function call may need to be interrupted and restarted.
   BOOST_ASIO_DECL bool enqueue_timer(const time_type& time,
-      timer_op* op, void* token);
+      per_timer_data& timer, timer_op* op);
 
   // Whether there are no timers in the queue.
   BOOST_ASIO_DECL virtual bool empty() const;
@@ -321,7 +355,7 @@
 
   // Cancel and dequeue the timers with the given token.
   BOOST_ASIO_DECL std::size_t cancel_timer(
-      void* timer_token, op_queue<operation>& ops);
+      per_timer_data& timer, op_queue<operation>& ops);
 
 private:
   timer_queue<forwarding_posix_time_traits> impl_;

Modified: trunk/boost/asio/detail/win_iocp_io_service.hpp
==============================================================================
--- trunk/boost/asio/detail/win_iocp_io_service.hpp	(original)
+++ trunk/boost/asio/detail/win_iocp_io_service.hpp	2010-07-04 03:37:42 EDT (Sun, 04 Jul 2010)
@@ -148,13 +148,15 @@
   // 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>& timer_queue,
-      const typename Time_Traits::time_type& time, timer_op* op, void* token);
+  void schedule_timer(timer_queue<Time_Traits>& queue,
+      const typename Time_Traits::time_type& time,
+      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op);
 
   // Cancel the timer associated with the given token. Returns the number of
   // handlers that have been posted or dispatched.
   template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& timer_queue, void* token);
+  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& timer);
 
 private:
 #if defined(WINVER) && (WINVER < 0x0500)