ACE/ace/Timer_Hash_T.cpp

   1 #ifndef ACE_TIMER_HASH_T_CPP
   2 #define ACE_TIMER_HASH_T_CPP
   3
   4 #include "ace/Timer_Hash_T.h"
   5
   6 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   7 # pragma once
   8 #endif /* ACE_LACKS_PRAGMA_ONCE */
   9
  10 #include "ace/OS_NS_sys_time.h"
  11 #include "ace/Guard_T.h"
  12 #include "ace/Log_Category.h"
  13
  14 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  15
  16 template <class TYPE>
  17 class Hash_Token
  18 {
  19 public:
  20   // This constructor is required by ACE_Locked_Free_List::alloc.
  21   Hash_Token () :
  22     act_ (0),
  23     pos_ (0),
  24     orig_id_ (0),
  25     next_ (0)
  26   {
  27   }
  28
  29   Hash_Token<TYPE> *get_next ()
  30   {
  31     return this->next_;
  32   }
  33
  34   void set_next (Hash_Token<TYPE> *next)
  35   {
  36     this->next_ = next;
  37   }
  38
  39   void set (const void *act,
  40             size_t pos,
  41             long orig_id,
  42             const TYPE &type)
  43   {
  44     this->act_ = act;
  45     this->pos_ = pos;
  46     this->orig_id_ = orig_id;
  47     this->type_ = type;
  48     this->next_ = 0;
  49   }
  50
  51   const void *act_;
  52   size_t pos_;
  53   long orig_id_;
  54   TYPE type_;
  55   /// Pointer to next token.
  56   Hash_Token<TYPE> *next_;
  57 };
  58
  59 // Default constructor
  60
  61 template <class TYPE, class FUNCTOR, class ACE_LOCK>
  62 ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>::ACE_Timer_Hash_Upcall ()
  63   : timer_hash_ (0)
  64 {
  65   // Nothing
  66 }
  67
  68 // Constructor that specifies a Timer_Hash to call up to
  69
  70 template <class TYPE, class FUNCTOR, class ACE_LOCK>
  71 ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>::ACE_Timer_Hash_Upcall (
  72   ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK> *timer_hash)
  73   : timer_hash_ (timer_hash)
  74 {
  75   // Nothing
  76 }
  77
  78 template <class TYPE, class FUNCTOR, class ACE_LOCK> int
  79 ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>::registration (
  80   TIMER_QUEUE &,
  81   ACE_Event_Handler *,
  82   const void *)
  83 {
  84   // Registration will be handled by the upcall functor of the timer
  85   // hash.
  86   return 0;
  87 }
  88
  89 template <class TYPE, class FUNCTOR, class ACE_LOCK> int
  90 ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>::preinvoke (TIMER_QUEUE &,
  91                                                            ACE_Event_Handler *,
  92                                                            const void *,
  93                                                            int,
  94                                                            const ACE_Time_Value &,
  95                                                            const void *&)
  96 {
  97   // This method should never be invoked since we don't invoke
  98   // expire() on the buckets.
  99   ACE_ASSERT (0);
 100   return 0;
 101 }
 102
 103 template <class TYPE, class FUNCTOR, class ACE_LOCK> int
 104 ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>::postinvoke (
 105   TIMER_QUEUE &,
 106   ACE_Event_Handler *,
 107   const void *,
 108   int,
 109   const ACE_Time_Value &,
 110   const void *)
 111 {
 112   // This method should never be invoked since we don't invoke
 113   // expire() on the buckets.
 114   ACE_ASSERT (0);
 115   return 0;
 116 }
 117
 118 // Calls up to timer_hash's upcall functor
 119 template <class TYPE, class FUNCTOR, class ACE_LOCK> int
 120 ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>::timeout (
 121   TIMER_QUEUE &,
 122   ACE_Event_Handler *,
 123   const void *,
 124   int,
 125   const ACE_Time_Value &)
 126 {
 127   // This method should never be invoked since we don't invoke
 128   // expire() on the buckets.
 129   ACE_ASSERT (0);
 130   return 0;
 131 }
 132
 133 template <class TYPE, class FUNCTOR, class ACE_LOCK> int
 134 ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>::cancel_type (
 135   TIMER_QUEUE &,
 136   ACE_Event_Handler *,
 137   int,
 138   int &)
 139 {
 140   // Cancellation will be handled by the upcall functor of the timer
 141   // hash.
 142   return 0;
 143 }
 144
 145 template <class TYPE, class FUNCTOR, class ACE_LOCK> int
 146 ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>::cancel_timer (
 147   TIMER_QUEUE &,
 148   ACE_Event_Handler *,
 149   int,
 150   int)
 151 {
 152   // Cancellation will be handled by the upcall functor of the timer
 153   // hash.
 154   return 0;
 155 }
 156
 157 template <class TYPE, class FUNCTOR, class ACE_LOCK> int
 158 ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>::deletion (
 159   TIMER_QUEUE &,
 160   ACE_Event_Handler *event_handler,
 161   const void *arg)
 162 {
 163   // Call up to the upcall functor of the timer hash since the timer
 164   // hash does not invoke deletion() on its upcall functor directly.
 165   Hash_Token<TYPE> *h =
 166     reinterpret_cast<Hash_Token<TYPE> *> (const_cast<void *> (arg));
 167
 168   int result =
 169     this->timer_hash_->upcall_functor ().
 170     deletion (*this->timer_hash_,
 171               event_handler,
 172               h->act_);
 173
 174   return result;
 175 }
 176
 177 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 178 ACE_Timer_Hash_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::ACE_Timer_Hash_Iterator_T (Hash & hash)
 179   : timer_hash_ (hash)
 180 {
 181   this->first ();
 182   // Nothing
 183 }
 184
 185 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 186 ACE_Timer_Hash_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::~ACE_Timer_Hash_Iterator_T ()
 187 {
 188   // Nothing
 189 }
 190
 191 // Positions the iterator at the first node in the timing hash table
 192
 193 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> void
 194 ACE_Timer_Hash_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::first ()
 195 {
 196   for (this->position_ = 0;
 197        this->position_ < this->timer_hash_.table_size_;
 198        ++this->position_)
 199     {
 200       // Check for an empty entry
 201       if (!this->timer_hash_.table_[this->position_]->is_empty ())
 202         {
 203           this->iter_ = &this->timer_hash_.table_[this->position_]->iter ();
 204           this->iter_->first ();
 205           return;
 206         }
 207     }
 208
 209   // Didn't find any
 210   this->iter_ = 0;
 211 }
 212
 213 // Positions the iterator at the next node in the bucket or goes to the next
 214 // bucket
 215
 216 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> void
 217 ACE_Timer_Hash_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::next ()
 218 {
 219   if (this->isdone ())
 220     return;
 221
 222   // If there is no more in the current bucket, go to the next
 223   if (this->iter_->isdone ())
 224     {
 225       for (++this->position_;
 226            this->position_ < this->timer_hash_.table_size_;
 227            ++this->position_)
 228         {
 229           // Check for an empty entry
 230           if (!this->timer_hash_.table_[this->position_]->is_empty ())
 231             {
 232               this->iter_ = &this->timer_hash_.table_[this->position_]->iter ();
 233               this->iter_->first ();
 234               return;
 235             }
 236         }
 237
 238       // Didn't find any.
 239       this->iter_ = 0;
 240     }
 241   else
 242     this->iter_->next ();
 243 }
 244
 245 // Returns true when we are at the end (when bucket_item_ == 0)
 246
 247 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> bool
 248 ACE_Timer_Hash_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::isdone () const
 249 {
 250   return this->iter_ == 0;
 251 }
 252
 253 // Returns the node at the current position in the sequence
 254
 255 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 256 ACE_Timer_Node_T<TYPE> *
 257 ACE_Timer_Hash_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::item ()
 258 {
 259   if (this->isdone ())
 260     return 0;
 261
 262   return this->iter_->item ();
 263 }
 264
 265 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 266 ACE_Timer_Queue_Iterator_T<TYPE> &
 267 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::iter ()
 268 {
 269   this->iterator_->first ();
 270   return *this->iterator_;
 271 }
 272
 273 // Create an empty queue.
 274
 275 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 276 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::ACE_Timer_Hash_T (
 277   size_t table_size,
 278   FUNCTOR *upcall_functor,
 279   ACE_Free_List<ACE_Timer_Node_T <TYPE> > *freelist,
 280   TIME_POLICY const & time_policy)
 281   : Base_Timer_Queue (upcall_functor, freelist, time_policy),
 282     size_ (0),
 283     table_size_ (table_size),
 284     table_functor_ (this),
 285     earliest_position_ (0),
 286     iterator_ (0)
 287 #if defined (ACE_WIN64)
 288   , pointer_base_ (0)
 289 #endif /* ACE_WIN64 */
 290   , token_list_ ()
 291 {
 292   ACE_TRACE ("ACE_Timer_Hash_T::ACE_Timer_Hash_T");
 293
 294   ACE_NEW (table_,
 295            BUCKET *[table_size]);
 296
 297   for (size_t i = 0;
 298        i < table_size;
 299        ++i)
 300     {
 301       ACE_NEW (this->table_[i],
 302                BUCKET (&this->table_functor_,
 303                       this->free_list_,
 304                       time_policy));
 305     }
 306
 307   ACE_NEW (iterator_,
 308            HASH_ITERATOR (*this));
 309 }
 310
 311
 312 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 313 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::ACE_Timer_Hash_T (
 314   FUNCTOR *upcall_functor,
 315   ACE_Free_List<ACE_Timer_Node_T <TYPE> > *freelist,
 316   TIME_POLICY const & time_policy)
 317   : Base_Timer_Queue (upcall_functor, freelist, time_policy),
 318     size_ (0),
 319     table_size_ (ACE_DEFAULT_TIMER_HASH_TABLE_SIZE),
 320     table_functor_ (this),
 321     earliest_position_ (0)
 322 #if defined (ACE_WIN64)
 323   , pointer_base_ (0)
 324 #endif /* ACE_WIN64 */
 325   , token_list_ ()
 326 {
 327   ACE_TRACE ("ACE_Timer_Hash_T::ACE_Timer_Hash_T");
 328
 329   ACE_NEW (table_,
 330            BUCKET *[ACE_DEFAULT_TIMER_HASH_TABLE_SIZE]);
 331
 332   for (size_t i = 0;
 333        i < this->table_size_;
 334        ++i)
 335     {
 336       ACE_NEW (this->table_[i],
 337                BUCKET (&this->table_functor_,
 338                       this->free_list_,
 339                       time_policy));
 340     }
 341
 342   ACE_NEW (iterator_,
 343            HASH_ITERATOR (*this));
 344 }
 345
 346 // Remove all remaining items in the Queue.
 347
 348 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 349 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::~ACE_Timer_Hash_T ()
 350 {
 351   ACE_TRACE ("ACE_Timer_Hash_T::~ACE_Timer_Hash_T");
 352   ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_));
 353
 354   delete iterator_;
 355
 356   this->close ();
 357
 358   for (size_t i = 0;
 359        i < this->table_size_;
 360        ++i)
 361     delete this->table_[i];
 362
 363
 364   delete [] this->table_;
 365 }
 366
 367 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> int
 368 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::close ()
 369 {
 370   ACE_TRACE ("ACE_Timer_Hash_T::close");
 371   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 372
 373   // Remove all remaining items from the queue.
 374   while (!this->is_empty())
 375     {
 376       ACE_Timer_Node_T<TYPE>* n = this->remove_first();
 377       this->upcall_functor ().deletion (*this,
 378                                         n->get_type(),
 379                                         n->get_act());
 380       this->free_node (n);
 381     }
 382
 383   // leave the rest to destructor
 384   return 0;
 385 }
 386
 387 // Checks if queue is empty.
 388
 389 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> bool
 390 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::is_empty () const
 391 {
 392   ACE_TRACE ("ACE_Timer_Hash_T::is_empty");
 393   return this->table_[this->earliest_position_]->is_empty ();
 394 }
 395
 396 // Returns earliest time in a non-empty bucket
 397
 398 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 399 const ACE_Time_Value &
 400 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::earliest_time () const
 401 {
 402   ACE_TRACE ("ACE_Timer_Hash_T::earliest_time");
 403   return this->table_[this->earliest_position_]->earliest_time ();
 404 }
 405
 406 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> void
 407 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::dump () const
 408 {
 409 #if defined (ACE_HAS_DUMP)
 410   ACE_TRACE ("ACE_Timer_Hash_T::dump");
 411   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 412   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\ntable_size_ = %d"), this->table_size_));
 413   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nearliest_position_ = %d"), this->earliest_position_));
 414
 415   for (size_t i = 0; i < this->table_size_; ++i)
 416     if (!this->table_[i]->is_empty ())
 417       ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nBucket %d contains nodes"), i));
 418
 419   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
 420   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 421 #endif /* ACE_HAS_DUMP */
 422 }
 423
 424 // Reschedule a periodic timer.  This function must be called with the
 425 // mutex lock held.
 426
 427 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 428 void
 429 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::reschedule (
 430   ACE_Timer_Node_T<TYPE> *expired)
 431 {
 432   ACE_TRACE ("ACE_Timer_Hash_T::reschedule");
 433
 434   Hash_Token<TYPE> *h =
 435     reinterpret_cast<Hash_Token<TYPE> *> (
 436       const_cast<void *> (expired->get_act ()));
 437
 438   // Don't use ACE_Utils::truncate_cast<> here.  A straight
 439   // static_cast<>  will provide more unique results when the number
 440   // of seconds is greater than std::numeric_limits<size_t>::max().
 441   size_t const secs_hash_input =
 442     static_cast<size_t> (expired->get_timer_value ().sec ());
 443   h->pos_ = secs_hash_input % this->table_size_;
 444
 445   h->orig_id_ =
 446     this->table_[h->pos_]->schedule (expired->get_type (),
 447                                      h,
 448                                      expired->get_timer_value (),
 449                                      expired->get_interval ());
 450   ACE_ASSERT (h->orig_id_ != -1);
 451
 452   // Since schedule() above will allocate a new node
 453   // then here schedule <expired> for deletion. Don't call
 454   // this->free_node() because that will invalidate <h>
 455   // and that's what user have as timer_id.
 456   Base_Timer_Queue::free_node (expired);
 457
 458   if (this->table_[this->earliest_position_]->is_empty ()
 459       || this->table_[h->pos_]->earliest_time ()
 460       < this->table_[this->earliest_position_]->earliest_time ())
 461     this->earliest_position_ = h->pos_;
 462 }
 463
 464 // Insert a new handler that expires at time future_time; if interval
 465 // is > 0, the handler will be reinvoked periodically.
 466
 467 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 468 long
 469 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::schedule_i (
 470   const TYPE &type,
 471   const void *act,
 472   const ACE_Time_Value &future_time,
 473   const ACE_Time_Value &interval)
 474 {
 475   ACE_TRACE ("ACE_Timer_Hash_T::schedule_i");
 476
 477   // Don't use ACE_Utils::truncate_cast<> here.  A straight
 478   // static_cast<>  will provide more unique results when the number
 479   // of seconds is greater than std::numeric_limits<size_t>::max().
 480   size_t const secs_hash_input = static_cast<size_t> (future_time.sec ());
 481   size_t const position = secs_hash_input % this->table_size_;
 482
 483   // Don't create Hash_Token directly. Instead we get one from Free_List
 484   // and then set it properly.
 485   Hash_Token<TYPE> *h = this->token_list_.remove ();
 486   h->set (act, position, 0, type);
 487
 488   h->orig_id_ =
 489     this->table_[position]->schedule (type,
 490                                       h,
 491                                       future_time,
 492                                       interval);
 493   ACE_ASSERT (h->orig_id_ != -1);
 494
 495   if (this->table_[this->earliest_position_]->is_empty ()
 496       || this->table_[position]->earliest_time ()
 497       < this->table_[this->earliest_position_]->earliest_time ())
 498     this->earliest_position_ = position;
 499
 500   ++this->size_;
 501
 502 #if defined (ACE_WIN64)
 503   // This is a Win64 hack, necessary because of the original (bad) decision
 504   // to use a pointer as the timer ID. This class doesn't follow the usual
 505   // timer expiration rules (see comments in header file) and is probably
 506   // not used much. The dynamic allocation of Hash_Tokens without
 507   // recording them anywhere is a large problem for Win64 since the
 508   // size of a pointer is 64 bits, but a long is 32. Since this class
 509   // is not much used, I'm hacking this, at least for now. If it becomes
 510   // an issue, I'll look at it again then.
 511   intptr_t hi = reinterpret_cast<intptr_t> (h);
 512   if (this->pointer_base_ == 0)
 513     this->pointer_base_ = hi & 0xffffffff00000000;
 514   return static_cast<long> (hi & 0xffffffff);
 515 #else
 516   return reinterpret_cast<long> (h);
 517 #endif
 518 }
 519
 520 // Locate and update the inteval on the timer_id
 521
 522 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 523 int
 524 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::reset_interval (
 525   long timer_id,
 526   const ACE_Time_Value & interval)
 527 {
 528   ACE_TRACE ("ACE_Timer_Hash_T::reset_interval");
 529
 530   // Make sure we are getting a valid <timer_id>, not an error
 531   // returned by <schedule>.
 532   if (timer_id == -1)
 533     return -1;
 534
 535 #if defined (ACE_WIN64)
 536   unsigned long const timer_offset =
 537     static_cast<unsigned long> (timer_id);
 538
 539   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 540
 541   Hash_Token<TYPE> * const h =
 542     reinterpret_cast<Hash_Token<TYPE> *> (this->pointer_base_ + timer_offset);
 543 #else
 544   Hash_Token<TYPE> * const h =
 545     reinterpret_cast<Hash_Token<TYPE> *> (timer_id);
 546
 547   // Grab the lock before accessing the table.  We don't need to do so
 548   // before this point since no members are accessed until now.
 549   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 550 #endif /* ACE_WIN64 */
 551
 552   return this->table_[h->pos_]->reset_interval (h->orig_id_,
 553                                                 interval);
 554 }
 555
 556 // Locate and remove the single <ACE_Event_Handler> with a value of
 557 // @a timer_id from the correct table timer queue.
 558
 559 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 560 int
 561 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::cancel (long timer_id,
 562                                                            const void **act,
 563                                                            int dont_call)
 564 {
 565   ACE_TRACE ("ACE_Timer_Hash_T::cancel");
 566
 567   // Make sure we are getting a valid <timer_id>, not an error
 568   // returned by <schedule>.
 569   if (timer_id == -1)
 570     return 0;
 571
 572 #if defined (ACE_WIN64)
 573   unsigned long const timer_offset =
 574     static_cast<unsigned long> (timer_id);
 575
 576   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 577
 578   Hash_Token<TYPE> * const h =
 579     reinterpret_cast<Hash_Token<TYPE> *> (this->pointer_base_ + timer_offset);
 580 #else
 581   Hash_Token<TYPE> * const h =
 582     reinterpret_cast<Hash_Token<TYPE> *> (timer_id);
 583
 584   // Grab the lock before accessing the table.  We don't need to do so
 585   // before this point since no members are accessed until now.
 586   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 587 #endif /* ACE_WIN64 */
 588
 589   int const result = this->table_[h->pos_]->cancel (h->orig_id_,
 590                                                     0,
 591                                                     dont_call);
 592
 593   if (result == 1)
 594     {
 595       // Call the close hooks.
 596       int cookie = 0;
 597
 598       // cancel_type() called once per <type>.
 599       this->upcall_functor ().cancel_type (*this,
 600                                            h->type_,
 601                                            dont_call,
 602                                            cookie);
 603
 604       // cancel_timer() called once per <timer>.
 605       this->upcall_functor ().cancel_timer (*this,
 606                                             h->type_,
 607                                             dont_call,
 608                                             cookie);
 609
 610       if (h->pos_ == this->earliest_position_)
 611         this->find_new_earliest ();
 612
 613       if (act != 0)
 614         *act = h->act_;
 615
 616       // We could destruct Hash_Token explicitly but we better
 617       // schedule it for destruction. In this case next
 618       // token_list_.remove () will use it.
 619       this->token_list_.add (h);
 620
 621       --this->size_;
 622     }
 623
 624   return result;
 625 }
 626
 627 // Locate and remove all values of <type> from the timer queue.
 628
 629 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY>
 630 int
 631 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::cancel (const TYPE &type,
 632                                                            int dont_call)
 633 {
 634   ACE_TRACE ("ACE_Timer_Hash_T::cancel");
 635
 636   size_t i; // loop variable.
 637
 638   Hash_Token<TYPE> **timer_ids = 0;
 639   size_t pos = 0;
 640
 641   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 642
 643   ACE_NEW_RETURN (timer_ids,
 644                   Hash_Token<TYPE> *[this->size_],
 645                   -1);
 646
 647   for (i = 0;
 648        i < this->table_size_;
 649        ++i)
 650     {
 651       ACE_Timer_Queue_Iterator_T<TYPE> & iter =
 652         this->table_[i]->iter ();
 653
 654       for (iter.first ();
 655            !iter.isdone ();
 656            iter.next ())
 657         if (iter.item ()->get_type () == type)
 658           timer_ids[pos++] =
 659             reinterpret_cast<Hash_Token<TYPE> *> (
 660               const_cast<void *> (iter.item ()->get_act ()));
 661     }
 662
 663   if (pos > this->size_)
 664     return -1;
 665
 666   for (i = 0; i < pos; ++i)
 667     {
 668       int const result =
 669         this->table_[timer_ids[i]->pos_]->cancel (timer_ids[i]->orig_id_,
 670                                                   0,
 671                                                   dont_call);
 672       ACE_ASSERT (result == 1);
 673       ACE_UNUSED_ARG (result);
 674
 675       // We could destruct Hash_Token explicitly but we better
 676       // schedule it for destruction.
 677       this->token_list_.add (timer_ids[i]);
 678
 679       --this->size_;
 680     }
 681
 682   delete [] timer_ids;
 683
 684   this->find_new_earliest ();
 685
 686   // Call the close hooks.
 687   int cookie = 0;
 688
 689   // cancel_type() called once per <type>.
 690   this->upcall_functor ().cancel_type (*this,
 691                                        type,
 692                                        dont_call,
 693                                        cookie);
 694
 695   for (i = 0;
 696        i < pos;
 697        ++i)
 698     {
 699       // cancel_timer() called once per <timer>.
 700       this->upcall_functor ().cancel_timer (*this,
 701                                             type,
 702                                             dont_call,
 703                                             cookie);
 704     }
 705
 706   return static_cast<int> (pos);
 707 }
 708
 709 // Removes the earliest node and finds the new earliest position
 710
 711 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> ACE_Timer_Node_T<TYPE> *
 712 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::remove_first ()
 713 {
 714   if (this->is_empty ())
 715     return 0;
 716
 717   ACE_Timer_Node_T<TYPE> *temp =
 718     this->table_[this->earliest_position_]->remove_first ();
 719
 720   this->find_new_earliest ();
 721
 722   --this->size_;
 723
 724   return temp;
 725 }
 726
 727 // Finds a new earliest position
 728
 729 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> void
 730 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::find_new_earliest ()
 731 {
 732   for (size_t i = 0; i < this->table_size_; ++i)
 733     if (!this->table_[i]->is_empty ())
 734       if (this->table_[this->earliest_position_]->is_empty ()
 735           || this->earliest_time () == ACE_Time_Value::zero
 736           || this->table_[i]->earliest_time () <= this->earliest_time ())
 737           this->earliest_position_ = i;
 738 }
 739
 740 // Returns the earliest node without removing it
 741
 742 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> ACE_Timer_Node_T<TYPE> *
 743 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::get_first ()
 744 {
 745   ACE_TRACE ("ACE_Timer_Hash_T::get_first");
 746
 747   if (this->is_empty ())
 748     return 0;
 749
 750   return this->table_[this->earliest_position_]->get_first ();
 751 }
 752
 753 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> void
 754 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::free_node (ACE_Timer_Node_T<TYPE> *node)
 755 {
 756   Base_Timer_Queue::free_node (node);
 757
 758   Hash_Token<TYPE> *h =
 759     reinterpret_cast<Hash_Token<TYPE> *> (const_cast<void *> (node->get_act ()));
 760   this->token_list_.add (h);
 761 }
 762
 763 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> int
 764 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::dispatch_info_i (const ACE_Time_Value &cur_time,
 765                                                                     ACE_Timer_Node_Dispatch_Info_T<TYPE> &info)
 766 {
 767   int const result =
 768     Base_Timer_Queue::dispatch_info_i (cur_time, info);
 769
 770   if (result == 1)
 771     {
 772       Hash_Token<TYPE> *h =
 773         reinterpret_cast<Hash_Token<TYPE> *> (const_cast<void *> (info.act_));
 774
 775       info.act_ = h->act_;
 776     }
 777
 778   return result;
 779 }
 780
 781 // Dummy version of expire to get rid of warnings in Sun CC 4.2
 782
 783 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> int
 784 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::expire ()
 785 {
 786   return Base_Timer_Queue::expire();
 787 }
 788
 789 // Specialized expire for Timer Hash
 790
 791 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET, typename TIME_POLICY> int
 792 ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY>::expire (const ACE_Time_Value &cur_time)
 793 {
 794   ACE_TRACE ("ACE_Timer_Hash_T::expire");
 795
 796   int number_of_timers_expired = 0;
 797
 798   ACE_Timer_Node_T<TYPE> *expired = 0;
 799
 800   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 801
 802   // Go through the table and expire anything that can be expired
 803
 804   for (size_t i = 0;
 805        i < this->table_size_;
 806        ++i)
 807     {
 808       while (!this->table_[i]->is_empty ()
 809              && this->table_[i]->earliest_time () <= cur_time)
 810         {
 811           expired = this->table_[i]->remove_first ();
 812           const void *act = expired->get_act ();
 813           bool reclaim = true;
 814
 815           Hash_Token<TYPE> *h =
 816             reinterpret_cast<Hash_Token<TYPE> *> (const_cast<void *> (act));
 817
 818           ACE_ASSERT (h->pos_ == i);
 819
 820           // Check if this is an interval timer.
 821           if (expired->get_interval () > ACE_Time_Value::zero)
 822             {
 823               // Make sure that we skip past values that have already
 824               // "expired".
 825               this->recompute_next_abs_interval_time (expired, cur_time);
 826
 827               // Since this is an interval timer, we need to
 828               // reschedule it.
 829               this->reschedule (expired);
 830               reclaim = false;
 831             }
 832           else
 833             {
 834               this->free_node (expired);
 835             }
 836
 837           ACE_Timer_Node_Dispatch_Info_T<TYPE> info;
 838
 839           // Get the dispatch info
 840           expired->get_dispatch_info (info);
 841
 842           info.act_ = h->act_;
 843
 844           const void *upcall_act = 0;
 845
 846           this->preinvoke (info, cur_time, upcall_act);
 847
 848           this->upcall (info, cur_time);
 849
 850           this->postinvoke (info, cur_time, upcall_act);
 851
 852           if (reclaim)
 853             {
 854               --this->size_;
 855             }
 856
 857           ++number_of_timers_expired;
 858          }
 859     }
 860
 861   if (number_of_timers_expired > 0)
 862     this->find_new_earliest ();
 863
 864   return number_of_timers_expired;
 865 }
 866
 867 ACE_END_VERSIONED_NAMESPACE_DECL
 868
 869 #endif /* ACE_TIMER_HASH_T_CPP */