---

ACE_Timer_Heap_T Class Template Reference

Provides a very fast and predictable timer implementation. More...

#include <Timer_Heap_T.h>

Inheritance diagram for ACE_Timer_Heap_T:

[legend]Collaboration diagram for ACE_Timer_Heap_T:

[legend]List of all members.

Public Types
typedef ACE_Timer_Heap_Iterator_T< TYPE, FUNCTOR, ACE_LOCK >	HEAP_ITERATOR
typedef ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >	INHERITED
Public Methods
	ACE_Timer_Heap_T (size_t size, int preallocated=0, FUNCTOR *upcall_functor=0, ACE_Free_List< ACE_Timer_Node_T< TYPE > > *freelist=0)
	ACE_Timer_Heap_T (FUNCTOR *upcall_functor=0, ACE_Free_List< ACE_Timer_Node_T< TYPE > > *freelist=0)
virtual	~ACE_Timer_Heap_T (void)
	Destructor. More...
virtual int	is_empty (void) const
	True if heap is empty, else false. More...
virtual const ACE_Time_Value &	earliest_time (void) const
	Returns the time of the earliest node in the Timer_Queue. Must be called on a non-empty queue. More...
virtual long	schedule (const TYPE &type, const void *act, const ACE_Time_Value &future_time, const ACE_Time_Value &interval=ACE_Time_Value::zero)
virtual int	reset_interval (long timer_id, const ACE_Time_Value &interval)
virtual int	cancel (const TYPE &type, int dont_call_handle_close=1)
virtual int	cancel (long timer_id, const void **act=0, int dont_call_handle_close=1)
virtual ACE_Timer_Queue_Iterator_T< TYPE, FUNCTOR, ACE_LOCK > &	iter (void)
	Returns a pointer to this <ACE_Timer_Queue>'s iterator. More...
ACE_Timer_Node_T< TYPE > *	remove_first (void)
virtual void	dump (void) const
	Dump the state of an object. More...
virtual ACE_Timer_Node_T< TYPE > *	get_first (void)
	Reads the earliest node from the queue and returns it. More...
Protected Methods
virtual void	reschedule (ACE_Timer_Node_T< TYPE > *)
	Reschedule an "interval" <ACE_Timer_Node>. More...
virtual ACE_Timer_Node_T< TYPE > *	alloc_node (void)
	Factory method that allocates a new node (uses operator new if we're *not* preallocating, otherwise uses an internal freelist). More...
virtual void	free_node (ACE_Timer_Node_T< TYPE > *)
Private Methods
ACE_Timer_Node_T< TYPE > *	remove (size_t slot)
	Remove and return the <slot>th <ACE_Timer_Node> and restore the heap property. More...
void	insert (ACE_Timer_Node_T< TYPE > *new_node)
	Insert new_node into the heap and restore the heap property. More...
void	grow_heap (void)
void	reheap_up (ACE_Timer_Node_T< TYPE > *new_node, size_t slot, size_t parent)
	Restore the heap property, starting at <slot>. More...
void	reheap_down (ACE_Timer_Node_T< TYPE > *moved_node, size_t slot, size_t child)
	Restore the heap property, starting at <slot>. More...
void	copy (size_t slot, ACE_Timer_Node_T< TYPE > *moved_node)
	Copy <moved_node> into the <slot> slot of <heap_> and move <slot> into the corresponding slot in the <timer_id_> array. More...
int	timer_id (void)
int	pop_freelist (void)
	Pops and returns a new timer id from the freelist. More...
void	push_freelist (int old_id)
	Pushes <old_id> onto the freelist. More...
	ACE_Timer_Heap_T (const ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK > &)
void	operator= (const ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK > &)
Private Attributes
size_t	max_size_
	Maximum size of the heap. More...
size_t	cur_size_
	Current size of the heap. More...
size_t	cur_limbo_
	Number of heap entries in transition (removed from the queue, but not freed) and may be rescheduled or freed. More...
HEAP_ITERATOR *	iterator_
	Iterator used to expire timers. More...
ACE_Timer_Node_T< TYPE > **	heap_
ssize_t *	timer_ids_
size_t	timer_ids_curr_
	"Pointer" to the element in the <timer_ids_> array that was last given out as a timer ID. More...
size_t	timer_ids_min_free_
	Index representing the lowest timer ID that has been freed. When the timer_ids_next_ value wraps around, it starts back at this point. More...
ACE_Timer_Node_T< TYPE > *	preallocated_nodes_
ACE_Timer_Node_T< TYPE > *	preallocated_nodes_freelist_
	This points to the head of the <preallocated_nodes_> freelist, which is organized as a stack. More...
ACE_Unbounded_Set< ACE_Timer_Node_T< TYPE > * >	preallocated_node_set_
	Set of pointers to the arrays of preallocated timer nodes. Used to delete the allocated memory when required. More...
Friends
class	ACE_Timer_Heap_Iterator_T< TYPE, FUNCTOR, ACE_LOCK >

---

Detailed Description

template<class TYPE, class FUNCTOR, class ACE_LOCK>
class ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >

Provides a very fast and predictable timer implementation.

This implementation uses a heap-based callout queue of absolute times. Therefore, in the average and worst case, scheduling, canceling, and expiring timers is O(log N) (where N is the total number of timers). In addition, we can also preallocate as many ACE_Timer_Node objects as there are slots in the heap. This allows us to completely remove the need for dynamic memory allocation, which is important for real-time systems.

Definition at line 84 of file Timer_Heap_T.h.

---

Member Typedef Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK> typedef ACE_Timer_Heap_Iterator_T<TYPE, FUNCTOR, ACE_LOCK> ACE_Timer_Heap_T::HEAP_ITERATOR

Definition at line 87 of file Timer_Heap_T.h.

template<class TYPE, class FUNCTOR, class ACE_LOCK> typedef ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK> ACE_Timer_Heap_T::INHERITED

Definition at line 90 of file Timer_Heap_T.h.

---

Constructor & Destructor Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::ACE_Timer_Heap_T (  size_t    size, int    preallocated = 0, FUNCTOR *    upcall_functor = 0, ACE_Free_List< ACE_Timer_Node_T< TYPE > > *    freelist = 0 )

The Constructor creates a heap with specified number of elements. This can also take in a upcall functor and freelist (if 0, then defaults will be created). Parameters: size  The maximum number of timers that can be inserted into the new object. preallocated  Default 0, if non-0 then all the memory for the ACE_Timer_Node objects will be pre-allocated. This saves time and is more predictable (though it requires more space). Otherwise, timer nodes are allocated as needed. freelist  is the freelist of timer nodes. upcall_functor  If 0 Timer Heap will create a default FUNCTOR. Definition at line 75 of file Timer_Heap_T.cpp. References ACE_NEW, ACE_TRACE, ACE_Unbounded_Set< ACE_Timer_Node_T< TYPE > * >::insert, iterator_, preallocated_node_set_, preallocated_nodes_, preallocated_nodes_freelist_, ssize_t, and timer_ids_. : ACE_Timer_Queue_T<TYPE,FUNCTOR,ACE_LOCK> (upcall_functor, freelist), max_size_ (size), cur_size_ (0), cur_limbo_ (0), timer_ids_curr_ (0), timer_ids_min_free_ (0), preallocated_nodes_ (0), preallocated_nodes_freelist_ (0) { ACE_TRACE ("ACE_Timer_Heap_T::ACE_Timer_Heap_T"); // Create the heap array. ACE_NEW (this->heap_, ACE_Timer_Node_T<TYPE> *[size]); // Create the parallel ACE_NEW (this->timer_ids_, ssize_t[size]); // Initialize the "freelist," which uses negative values to // distinguish freelist elements from "pointers" into the <heap_> // array. for (size_t i = 0; i < size; i++) this->timer_ids_[i] = -1; if (preallocate) { ACE_NEW (this->preallocated_nodes_, ACE_Timer_Node_T<TYPE>[size]); // Add allocated array to set of such arrays for deletion on // cleanup. this->preallocated_node_set_.insert (this->preallocated_nodes_); // Form the freelist by linking the next_ pointers together. for (size_t j = 1; j < size; j++) this->preallocated_nodes_[j - 1].set_next (&this->preallocated_nodes_[j]); // NULL-terminate the freelist. this->preallocated_nodes_[size - 1].set_next (0); // Assign the freelist pointer to the front of the list. this->preallocated_nodes_freelist_ = &this->preallocated_nodes_[0]; } ACE_NEW (iterator_, HEAP_ITERATOR (*this)); }

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::ACE_Timer_Heap_T (  FUNCTOR *    upcall_functor = 0, ACE_Free_List< ACE_Timer_Node_T< TYPE > > *    freelist = 0 )

Default constructor. upcall_functor is the instance of the FUNCTOR to be used by the queue. If upcall_functor is 0, Timer Heap will create a default FUNCTOR. freelist is the freelist of timer nodes. If 0, then a default freelist will be created. The default size will be ACE_DEFAULT_TIMERS and there will be no preallocation. Definition at line 134 of file Timer_Heap_T.cpp. References ACE_DEFAULT_TIMERS, ACE_NEW, ACE_TRACE, iterator_, max_size_, ssize_t, and timer_ids_. : ACE_Timer_Queue_T<TYPE,FUNCTOR,ACE_LOCK> (upcall_functor, freelist), max_size_ (ACE_DEFAULT_TIMERS), cur_size_ (0), cur_limbo_ (0), timer_ids_curr_ (0), timer_ids_min_free_ (0), preallocated_nodes_ (0), preallocated_nodes_freelist_ (0) { ACE_TRACE ("ACE_Timer_Heap_T::ACE_Timer_Heap_T"); // Create the heap array. #if defined (__IBMCPP__) && (__IBMCPP__ >= 400) && defined (_WINDOWS) ACE_NEW (this->heap_, ACE_Timer_Node_T<TYPE> *[ACE_DEFAULT_TIMERS]); #else ACE_NEW (this->heap_, ACE_Timer_Node_T<TYPE> *[this->max_size_]); #endif /* defined (__IBMCPP__) && (__IBMCPP__ >= 400) && defined (_WINDOWS) */ // Create the parallel array. ACE_NEW (this->timer_ids_, ssize_t[this->max_size_]); // Initialize the "freelist," which uses negative values to // distinguish freelist elements from "pointers" into the <heap_> // array. for (size_t i = 0; i < this->max_size_; i++) this->timer_ids_[i] = -1; ACE_NEW (iterator_, HEAP_ITERATOR (*this)); }

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::~ACE_Timer_Heap_T (  void    )  [virtual]

Destructor. Definition at line 171 of file Timer_Heap_T.cpp. References ACE_TRACE, ACE_Unbounded_Set_Iterator::advance, cur_size_, free_node, heap_, iterator_, ACE_Unbounded_Set_Iterator::next, preallocated_nodes_, timer_ids_, and ACE_Timer_Queue_T::upcall_functor. { ACE_TRACE ("ACE_Timer_Heap_T::~ACE_Timer_Heap_T"); delete iterator_; // Clean up all the nodes still in the queue for (size_t i = 0; i < this->cur_size_; i++) { this->upcall_functor ().deletion (*this, this->heap_[i]->get_type (), this->heap_[i]->get_act ()); this->free_node (this->heap_[i]); } delete [] this->heap_; delete [] this->timer_ids_; // clean up any preallocated timer nodes if (preallocated_nodes_ != 0) { ACE_Unbounded_Set_Iterator<ACE_Timer_Node_T<TYPE> *> set_iterator (this->preallocated_node_set_); for (ACE_Timer_Node_T<TYPE> **entry = 0; set_iterator.next (entry) !=0; set_iterator.advance ()) delete [] *entry; } }

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::ACE_Timer_Heap_T (  const ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK > &    )  [private]

---

Member Function Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Node_T< TYPE > * ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::alloc_node (  void    )  [protected, virtual]

Factory method that allocates a new node (uses operator new if we're *not* preallocating, otherwise uses an internal freelist). Reimplemented from ACE_Timer_Queue_T. Definition at line 570 of file Timer_Heap_T.cpp. References ACE_NEW_RETURN, grow_heap, preallocated_nodes_, and preallocated_nodes_freelist_. { ACE_Timer_Node_T<TYPE> *temp = 0; // Only allocate a node if we are *not* using the preallocated heap. if (this->preallocated_nodes_ == 0) ACE_NEW_RETURN (temp, ACE_Timer_Node_T<TYPE>, 0); else { // check to see if the heap needs to grow if (this->preallocated_nodes_freelist_ == 0) this->grow_heap (); temp = this->preallocated_nodes_freelist_; // Remove the first element from the freelist. this->preallocated_nodes_freelist_ = this->preallocated_nodes_freelist_->get_next (); } return temp; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> int ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::cancel (  long    timer_id, const void **    act = 0, int    dont_call_handle_close = 1 )  [virtual]

Cancel the single timer that matches the <timer_id> value (which was returned from the <schedule> method). If act is non-NULL then it will be set to point to the ``magic cookie'' argument passed in when the timer was registered. This makes it possible to free up the memory and avoid memory leaks. If <dont_call> is 0 then the <functor> will be invoked. Returns 1 if cancellation succeeded and 0 if the <timer_id> wasn't found. Implements ACE_Timer_Queue_T. Definition at line 653 of file Timer_Heap_T.cpp. References ACE_ASSERT, ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, free_node, ACE_Timer_Node_T::get_act, ACE_Timer_Node_T::get_type, heap_, max_size_, remove, ssize_t, timer_id, timer_ids_, and ACE_Timer_Queue_T::upcall_functor. { ACE_TRACE ("ACE_Timer_Heap_T::cancel"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); // Locate the ACE_Timer_Node that corresponds to the timer_id. // Check to see if the timer_id is out of range if (timer_id < 0 || (size_t) timer_id > this->max_size_) return 0; ssize_t timer_node_slot = this->timer_ids_[timer_id]; // Check to see if timer_id is still valid. if (timer_node_slot < 0) return 0; if (timer_id != this->heap_[timer_node_slot]->get_timer_id ()) { ACE_ASSERT (timer_id == this->heap_[timer_node_slot]->get_timer_id ()); return 0; } else { ACE_Timer_Node_T<TYPE> *temp = this->remove (timer_node_slot); if (dont_call == 0) // Call the close hook. this->upcall_functor ().cancellation (*this, temp->get_type ()); if (act != 0) *act = temp->get_act (); this->free_node (temp); return 1; } }

template<class TYPE, class FUNCTOR, class ACE_LOCK> int ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::cancel (  const TYPE &    type, int    dont_call_handle_close = 1 )  [virtual]

Cancel all timers associated with <type>. If <dont_call> is 0 then the <functor> will be invoked. Returns number of timers cancelled. Implements ACE_Timer_Queue_T. Definition at line 734 of file Timer_Heap_T.cpp. References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, cur_size_, free_node, heap_, remove, and ACE_Timer_Queue_T::upcall_functor. { ACE_TRACE ("ACE_Timer_Heap_T::cancel"); int number_of_cancellations = 0; // Try to locate the ACE_Timer_Node that matches the timer_id. { ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); for (size_t i = 0; i < this->cur_size_; ) { if (this->heap_[i]->get_type () == type) { ACE_Timer_Node_T<TYPE> *temp = this->remove (i); number_of_cancellations++; this->free_node (temp); } else i++; } } if (dont_call == 0) this->upcall_functor ().cancellation (*this, type); return number_of_cancellations; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::copy (  size_t    slot, ACE_Timer_Node_T< TYPE > *    moved_node )  [private]

Copy <moved_node> into the <slot> slot of <heap_> and move <slot> into the corresponding slot in the <timer_id_> array. Definition at line 331 of file Timer_Heap_T.cpp. References ACE_ASSERT, ACE_Timer_Node_T::get_timer_id, heap_, max_size_, and timer_ids_. Referenced by reheap_down, reheap_up, and remove. { // Insert <moved_node> into its new location in the heap. this->heap_[slot] = moved_node; ACE_ASSERT (moved_node->get_timer_id () >= 0 && moved_node->get_timer_id () < (int) this->max_size_); // Update the corresponding slot in the parallel <timer_ids_> array. this->timer_ids_[moved_node->get_timer_id ()] = slot; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::dump (  void    )  const [virtual]

Dump the state of an object. Reimplemented from ACE_Timer_Queue_T. Definition at line 296 of file Timer_Heap_T.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, cur_size_, heap_, LM_DEBUG, and max_size_. { ACE_TRACE ("ACE_Timer_Heap_T::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nmax_size_ = %d"), this->max_size_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ncur_size_ = %d"), this->cur_size_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ncur_limbo_= %d"), this->cur_limbo_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nids_curr_ = %d"), this->timer_ids_curr_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nmin_free_ = %d"), this->timer_ids_min_free_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nheap_ = \n"))); for (size_t i = 0; i < this->cur_size_; i++) { ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("%d\n"), i)); this->heap_[i]->dump (); } ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ntimer_ids_ = \n"))); for (size_t j = 0; j < this->max_size_; j++) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("%d\t%d\n"), j, this->timer_ids_[j])); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); }

template<class TYPE, class FUNCTOR, class ACE_LOCK> const ACE_Time_Value & ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::earliest_time (  void    )  const [virtual]

Returns the time of the earliest node in the Timer_Queue. Must be called on a non-empty queue. Implements ACE_Timer_Queue_T. Definition at line 289 of file Timer_Heap_T.cpp. References ACE_TRACE, and heap_. { ACE_TRACE ("ACE_Timer_Heap_T::earliest_time"); return this->heap_[0]->get_timer_value (); }

template<class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::free_node (  ACE_Timer_Node_T< TYPE > *    )  [protected, virtual]

Factory method that frees a previously allocated node (uses operator delete if we're *not* preallocating, otherwise uses an internal freelist). Reimplemented from ACE_Timer_Queue_T. Definition at line 595 of file Timer_Heap_T.cpp. References ACE_Timer_Node_T::get_timer_id, preallocated_nodes_, preallocated_nodes_freelist_, push_freelist, and ACE_Timer_Node_T::set_next. Referenced by cancel, and ~ACE_Timer_Heap_T. { // Return this timer id to the freelist. this->push_freelist (node->get_timer_id ()); // Only free up a node if we are *not* using the preallocated heap. if (this->preallocated_nodes_ == 0) delete node; else { node->set_next (this->preallocated_nodes_freelist_); this->preallocated_nodes_freelist_ = node; } }

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Node_T< TYPE > * ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::get_first (  void    )  [virtual]

Reads the earliest node from the queue and returns it. Implements ACE_Timer_Queue_T. Definition at line 780 of file Timer_Heap_T.cpp. References ACE_TRACE, cur_size_, and heap_. { ACE_TRACE ("ACE_Timer_Heap_T::get_first"); return this->cur_size_ == 0 ? 0 : this->heap_[0]; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::grow_heap (  void    )  [private]

Doubles the size of the heap and the corresponding timer_ids array. If preallocation is used, will also double the size of the preallocated array of ACE_Timer_Nodes. Definition at line 467 of file Timer_Heap_T.cpp. References ACE_NEW, ACE_Timer_Node_T::get_next, heap_, ACE_Unbounded_Set< ACE_Timer_Node_T< TYPE > * >::insert, max_size_, ACE_OS_String::memcpy, preallocated_node_set_, preallocated_nodes_, preallocated_nodes_freelist_, ACE_Timer_Node_T::set_next, ssize_t, and timer_ids_. Referenced by alloc_node, and insert. { // All the containers will double in size from max_size_ size_t new_size = this->max_size_ * 2; // First grow the heap itself. ACE_Timer_Node_T<TYPE> **new_heap = 0; #if defined (__IBMCPP__) && (__IBMCPP__ >= 400) && defined (_WINDOWS) ACE_NEW (new_heap, ACE_Timer_Node_T<TYPE> *[1024]); #else ACE_NEW (new_heap, ACE_Timer_Node_T<TYPE> *[new_size]); #endif /* defined (__IBMCPP__) && (__IBMCPP__ >= 400) && defined (_WINDOWS) */ ACE_OS::memcpy (new_heap, this->heap_, this->max_size_ * sizeof *new_heap); delete [] this->heap_; this->heap_ = new_heap; // Grow the array of timer ids. ssize_t *new_timer_ids = 0; ACE_NEW (new_timer_ids, ssize_t[new_size]); ACE_OS::memcpy (new_timer_ids, this->timer_ids_, this->max_size_ * sizeof (ssize_t)); delete [] timer_ids_; this->timer_ids_ = new_timer_ids; // And add the new elements to the end of the "freelist". for (size_t i = this->max_size_; i < new_size; i++) this->timer_ids_[i] = -(ACE_static_cast (ssize_t, i) + 1); // Grow the preallocation array (if using preallocation) if (this->preallocated_nodes_ != 0) { // Create a new array with max_size elements to link in to // existing list. #if defined (__IBMCPP__) && (__IBMCPP__ >= 400) && defined (_WINDOWS) ACE_NEW (this->preallocated_nodes_, ACE_Timer_Node_T<TYPE>[88]); #else ACE_NEW (this->preallocated_nodes_, ACE_Timer_Node_T<TYPE>[this->max_size_]); #endif /* defined (__IBMCPP__) && (__IBMCPP__ >= 400) && defined (_WINDOWS) */ // Add it to the set for later deletion this->preallocated_node_set_.insert (this->preallocated_nodes_); // Link new nodes together (as for original list). for (size_t k = 1; k < this->max_size_; k++) this->preallocated_nodes_[k - 1].set_next (&this->preallocated_nodes_[k]); // NULL-terminate the new list. this->preallocated_nodes_[this->max_size_ - 1].set_next (0); // Link new array to the end of the existling list. if (this->preallocated_nodes_freelist_ == 0) this->preallocated_nodes_freelist_ = &preallocated_nodes_[0]; else { ACE_Timer_Node_T<TYPE> *previous = this->preallocated_nodes_freelist_; for (ACE_Timer_Node_T<TYPE> *current = this->preallocated_nodes_freelist_->get_next (); current != 0; current = current->get_next ()) previous = current; previous->set_next (&this->preallocated_nodes_[0]); } } this->max_size_ = new_size; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::insert (  ACE_Timer_Node_T< TYPE > *    new_node )  [private]

Insert new_node into the heap and restore the heap property. Definition at line 455 of file Timer_Heap_T.cpp. References ACE_HEAP_PARENT, cur_size_, grow_heap, max_size_, and reheap_up. Referenced by reschedule, and schedule. { if (this->cur_size_ + 2 >= this->max_size_) this->grow_heap (); this->reheap_up (new_node, this->cur_size_, ACE_HEAP_PARENT (this->cur_size_)); this->cur_size_++; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> int ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::is_empty (  void    )  const [virtual]

True if heap is empty, else false. Implements ACE_Timer_Queue_T. Definition at line 273 of file Timer_Heap_T.cpp. References ACE_TRACE, and cur_size_. { ACE_TRACE ("ACE_Timer_Heap_T::is_empty"); return this->cur_size_ == 0; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Queue_Iterator_T< TYPE, FUNCTOR, ACE_LOCK > & ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::iter (  void    )  [virtual]

Returns a pointer to this <ACE_Timer_Queue>'s iterator. Implements ACE_Timer_Queue_T. Definition at line 280 of file Timer_Heap_T.cpp. References ACE_Timer_Heap_Iterator_T::first, and iterator_. { this->iterator_->first (); return *this->iterator_; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::operator= (  const ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK > &    )  [private]

template<class TYPE, class FUNCTOR, class ACE_LOCK> int ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::pop_freelist (  void    )  [private]

Pops and returns a new timer id from the freelist. Definition at line 203 of file Timer_Heap_T.cpp. References ACE_ASSERT, ACE_TRACE, max_size_, timer_ids_, timer_ids_curr_, and timer_ids_min_free_. Referenced by timer_id. { ACE_TRACE ("ACE_Timer_Heap_T::pop_freelist"); // Scan for a free timer ID. Note that since this function is called // _after_ the check for a full timer heap, we are guaranteed to find // a free ID, even if we need to wrap around and start reusing freed IDs. // On entry, the curr_ index is at the previous ID given out; start // up where we left off last time. // NOTE - a timer_ids_ slot with -2 is out of the heap, but not freed. // It must be either freed (free_node) or rescheduled (reschedule). ++this->timer_ids_curr_; while (this->timer_ids_curr_ < this->max_size_ && (this->timer_ids_[this->timer_ids_curr_] >= 0 || this->timer_ids_[this->timer_ids_curr_] == -2 )) ++this->timer_ids_curr_; if (this->timer_ids_curr_ == this->max_size_) { ACE_ASSERT (this->timer_ids_min_free_ < this->max_size_); this->timer_ids_curr_ = this->timer_ids_min_free_; // We restarted the free search at min. Since min won't be // free anymore, and curr_ will just keep marching up the list // on each successive need for an ID, reset min_free_ to the // size of the list until an ID is freed that curr_ has already // gone past (see push_freelist). this->timer_ids_min_free_ = this->max_size_; } // We need to truncate this to <int> for backwards compatibility. int new_id = ACE_static_cast (int, this->timer_ids_curr_); return new_id; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::push_freelist (  int    old_id )  [private]

Pushes <old_id> onto the freelist. Definition at line 238 of file Timer_Heap_T.cpp. References ACE_ASSERT, ACE_TRACE, cur_limbo_, cur_size_, timer_ids_, timer_ids_curr_, and timer_ids_min_free_. Referenced by free_node. { ACE_TRACE ("ACE_Timer_Heap_T::push_freelist"); // Since this ID has already been checked by one of the public // functions, it's safe to cast it here. size_t oldid = size_t (old_id); // The freelist values in the <timer_ids_> are negative, so set the // freed entry back to 'free'. If this is the new lowest value free // timer ID that curr_ won't see on it's normal march through the list, // remember it. ACE_ASSERT (this->timer_ids_[oldid] >= 0 || this->timer_ids_[oldid] == -2); if (this->timer_ids_[oldid] == -2) --this->cur_limbo_; else --this->cur_size_; this->timer_ids_[oldid] = -1; if (oldid < this->timer_ids_min_free_ && oldid <= this->timer_ids_curr_) this->timer_ids_min_free_ = oldid; return; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::reheap_down (  ACE_Timer_Node_T< TYPE > *    moved_node, size_t    slot, size_t    child )  [private]

Restore the heap property, starting at <slot>. Definition at line 394 of file Timer_Heap_T.cpp. References ACE_HEAP_LCHILD, copy, cur_size_, ACE_Timer_Node_T::get_timer_value, and heap_. Referenced by remove. { // Restore the heap property after a deletion. while (child < this->cur_size_) { // Choose the smaller of the two children. if (child + 1 < this->cur_size_ && this->heap_[child + 1]->get_timer_value () < this->heap_[child]->get_timer_value ()) child++; // Perform a <copy> if the child has a larger timeout value than // the <moved_node>. if (this->heap_[child]->get_timer_value () < moved_node->get_timer_value ()) { this->copy (slot, this->heap_[child]); slot = child; child = ACE_HEAP_LCHILD (child); } else // We've found our location in the heap. break; } this->copy (slot, moved_node); }

template<class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::reheap_up (  ACE_Timer_Node_T< TYPE > *    new_node, size_t    slot, size_t    parent )  [private]

Restore the heap property, starting at <slot>. Definition at line 427 of file Timer_Heap_T.cpp. References ACE_HEAP_PARENT, copy, ACE_Timer_Node_T::get_timer_value, and heap_. Referenced by insert, and remove. { // Restore the heap property after an insertion. while (slot > 0) { // If the parent node is greater than the <moved_node> we need // to copy it down. if (moved_node->get_timer_value () < this->heap_[parent]->get_timer_value ()) { this->copy (slot, this->heap_[parent]); slot = parent; parent = ACE_HEAP_PARENT (slot); } else break; } // Insert the new node into its proper resting place in the heap and // update the corresponding slot in the parallel <timer_ids> array. this->copy (slot, moved_node); }

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Node_T< TYPE > * ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::remove (  size_t    slot )  [private]

Remove and return the <slot>th <ACE_Timer_Node> and restore the heap property. Definition at line 350 of file Timer_Heap_T.cpp. References ACE_HEAP_LCHILD, ACE_HEAP_PARENT, copy, cur_limbo_, cur_size_, ACE_Timer_Node_T::get_timer_id, ACE_Timer_Node_T::get_timer_value, heap_, reheap_down, reheap_up, and timer_ids_. Referenced by cancel, and remove_first. { ACE_Timer_Node_T<TYPE> *removed_node = this->heap_[slot]; // NOTE - the cur_size_ is being decremented since the queue has one // less active timer in it. However, this ACE_Timer_Node is not being // freed, and there is still a place for it in timer_ids_ (the timer ID // is not being relinquished). The node can still be rescheduled, or // it can be freed via free_node. --this->cur_size_; // Only try to reheapify if we're not deleting the last entry. if (slot < this->cur_size_) { ACE_Timer_Node_T<TYPE> *moved_node = this->heap_[this->cur_size_]; // Move the end node to the location being removed and update // the corresponding slot in the parallel <timer_ids> array. this->copy (slot, moved_node); // If the <moved_node->time_value_> is great than or equal its // parent it needs be moved down the heap. size_t parent = ACE_HEAP_PARENT (slot); if (moved_node->get_timer_value () >= this->heap_[parent]->get_timer_value ()) this->reheap_down (moved_node, slot, ACE_HEAP_LCHILD (slot)); else this->reheap_up (moved_node, slot, parent); } this->timer_ids_[removed_node->get_timer_id ()] = -2; ++this->cur_limbo_; return removed_node; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Node_T< TYPE > * ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::remove_first (  void    )  [virtual]

Removes the earliest node from the queue and returns it. Note that the timer is removed from the heap, but is not freed, and its ID is not reclaimed. The caller is responsible for calling either reschedule() or free_node() after this function returns. Thus, this function is for support of ACE_Timer_Queue::expire and should not be used unadvisedly in other conditions. Implements ACE_Timer_Queue_T. Definition at line 769 of file Timer_Heap_T.cpp. References ACE_TRACE, cur_size_, and remove. { ACE_TRACE ("ACE_Timer_Heap_T::remove_first"); if (this->cur_size_ == 0) return 0; return this->remove (0); }

template<class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::reschedule (  ACE_Timer_Node_T< TYPE > *    )  [protected, virtual]

Reschedule an "interval" <ACE_Timer_Node>. Implements ACE_Timer_Queue_T. Definition at line 555 of file Timer_Heap_T.cpp. References ACE_TRACE, cur_limbo_, ACE_Timer_Node_T::get_timer_id, insert, and timer_ids_. { ACE_TRACE ("ACE_Timer_Heap_T::reschedule"); // If we are rescheduling, then the most recent call was to // remove_first (). That called remove () to remove the node from the // heap, but did not free the timer ID. The ACE_Timer_Node still has // its assigned ID - just needs to be inserted at the new proper // place, and the heap restored properly. if (this->timer_ids_[expired->get_timer_id ()] == -2) --this->cur_limbo_; this->insert (expired); }

template<class TYPE, class FUNCTOR, class ACE_LOCK> int ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::reset_interval (  long    timer_id, const ACE_Time_Value &    interval )  [virtual]

Resets the interval of the timer represented by <timer_id> to <interval>, which is specified in relative time to the current <gettimeofday>. If <interval> is equal to <ACE_Time_Value::zero>, the timer will become a non-rescheduling timer. Returns 0 if successful, -1 if not. Implements ACE_Timer_Queue_T. Definition at line 699 of file Timer_Heap_T.cpp. References ACE_ASSERT, ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, heap_, max_size_, ssize_t, timer_id, and timer_ids_. { ACE_TRACE ("ACE_Timer_Heap_T::reset_interval"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); // Locate the ACE_Timer_Node that corresponds to the timer_id. // Check to see if the timer_id is out of range if (timer_id < 0 || (size_t) timer_id > this->max_size_) return -1; ssize_t timer_node_slot = this->timer_ids_[timer_id]; // Check to see if timer_id is still valid. if (timer_node_slot < 0) return -1; if (timer_id != this->heap_[timer_node_slot]->get_timer_id ()) { ACE_ASSERT (timer_id == this->heap_[timer_node_slot]->get_timer_id ()); return -1; } else { // Reset the timer interval this->heap_[timer_node_slot]->set_interval (interval); return 0; } }

template<class TYPE, class FUNCTOR, class ACE_LOCK> long ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::schedule (  const TYPE &    type, const void *    act, const ACE_Time_Value &    future_time, const ACE_Time_Value &    interval = ACE_Time_Value::zero )  [virtual]

Schedule a timer that may optionally auto-reset. Schedule <type> that will expire at <future_time>, which is specified in absolute time. If it expires then <act> is passed in as the value to the <functor>. If <interval> is != to <ACE_Time_Value::zero> then it is used to reschedule the <type> automatically, using relative time to the current <gettimeofday>. This method returns a <timer_id> that uniquely identifies the the <type> entry in an internal list. This <timer_id> can be used to cancel the timer before it expires. The cancellation ensures that <timer_ids> are unique up to values of greater than 2 billion timers. As long as timers don't stay around longer than this there should be no problems with accidentally deleting the wrong timer. Returns -1 on failure (which is guaranteed never to be a valid <timer_id>). Implements ACE_Timer_Queue_T. Definition at line 615 of file Timer_Heap_T.cpp. References ACE_ALLOCATOR_RETURN, ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, cur_limbo_, cur_size_, insert, max_size_, ACE_Timer_Node_T::set, and timer_id. { ACE_TRACE ("ACE_Timer_Heap_T::schedule"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); if ((this->cur_size_ + this->cur_limbo_) < this->max_size_) { // Obtain the next unique sequence number. int timer_id = this->timer_id (); // Obtain the memory to the new node. ACE_Timer_Node_T<TYPE> *temp = 0; ACE_ALLOCATOR_RETURN (temp, this->alloc_node (), -1); temp->set (type, act, future_time, interval, 0, timer_id); this->insert (temp); return timer_id; } else return -1; }

template<class TYPE, class FUNCTOR, class ACE_LOCK> int ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::timer_id (  void    )  [private]

Returns a timer id that uniquely identifies this timer. This id can be used to cancel a timer via the <cancel (int)> method. The timer id returned from this method will never == -1 to avoid conflicts with other failure return values. Definition at line 262 of file Timer_Heap_T.cpp. References ACE_TRACE, and pop_freelist. Referenced by cancel, reset_interval, and schedule. { ACE_TRACE ("ACE_Timer_Heap_T::timer_id"); // Return the next item off the freelist and use it as the timer id. return this->pop_freelist (); }

---

Friends And Related Function Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK> friend class ACE_Timer_Heap_Iterator_T< TYPE, FUNCTOR, ACE_LOCK > [friend]

Definition at line 88 of file Timer_Heap_T.h.

---

Member Data Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK> size_t ACE_Timer_Heap_T::cur_limbo_ [private]

Number of heap entries in transition (removed from the queue, but not freed) and may be rescheduled or freed. Definition at line 269 of file Timer_Heap_T.h. Referenced by push_freelist, remove, reschedule, and schedule.

template<class TYPE, class FUNCTOR, class ACE_LOCK> size_t ACE_Timer_Heap_T::cur_size_ [private]

Current size of the heap. Definition at line 265 of file Timer_Heap_T.h. Referenced by cancel, dump, get_first, insert, is_empty, push_freelist, reheap_down, remove, remove_first, schedule, and ~ACE_Timer_Heap_T.

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Node_T<TYPE>** ACE_Timer_Heap_T::heap_ [private]

Current contents of the Heap, which is organized as a "heap" of <ACE_Timer_Node> *'s. In this context, a heap is a "partially ordered, almost complete" binary tree, which is stored in an array. Definition at line 280 of file Timer_Heap_T.h. Referenced by cancel, copy, dump, earliest_time, get_first, grow_heap, reheap_down, reheap_up, remove, reset_interval, and ~ACE_Timer_Heap_T.

template<class TYPE, class FUNCTOR, class ACE_LOCK> HEAP_ITERATOR* ACE_Timer_Heap_T::iterator_ [private]

Iterator used to expire timers. Definition at line 272 of file Timer_Heap_T.h. Referenced by ACE_Timer_Heap_T, iter, and ~ACE_Timer_Heap_T.

template<class TYPE, class FUNCTOR, class ACE_LOCK> size_t ACE_Timer_Heap_T::max_size_ [private]

Maximum size of the heap. Definition at line 262 of file Timer_Heap_T.h. Referenced by ACE_Timer_Heap_T, cancel, copy, dump, grow_heap, insert, pop_freelist, reset_interval, and schedule.

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Unbounded_Set<ACE_Timer_Node_T<TYPE> *> ACE_Timer_Heap_T::preallocated_node_set_ [private]

Set of pointers to the arrays of preallocated timer nodes. Used to delete the allocated memory when required. Definition at line 317 of file Timer_Heap_T.h. Referenced by ACE_Timer_Heap_T, and grow_heap.

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Node_T<TYPE>* ACE_Timer_Heap_T::preallocated_nodes_ [private]

If this is non-0, then we preallocate <max_size_> number of <ACE_Timer_Node> objects in order to reduce dynamic allocation costs. In auto-growing implementation, this points to the last array of nodes allocated. Definition at line 309 of file Timer_Heap_T.h. Referenced by ACE_Timer_Heap_T, alloc_node, free_node, grow_heap, and ~ACE_Timer_Heap_T.

template<class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Node_T<TYPE>* ACE_Timer_Heap_T::preallocated_nodes_freelist_ [private]

This points to the head of the <preallocated_nodes_> freelist, which is organized as a stack. Definition at line 313 of file Timer_Heap_T.h. Referenced by ACE_Timer_Heap_T, alloc_node, free_node, and grow_heap.

template<class TYPE, class FUNCTOR, class ACE_LOCK> ssize_t* ACE_Timer_Heap_T::timer_ids_ [private]

An array of "pointers" that allows each <ACE_Timer_Node> in the <heap_> to be located in O(1) time. Basically, <timer_id_[i]> contains the slot in the <heap_> array where an <ACE_Timer_Node> * with timer id <i> resides. Thus, the timer id passed back from <schedule> is really a slot into the <timer_ids> array. The <timer_ids_> array serves two purposes: negative values are indications of free timer IDs, whereas positive values are "pointers" into the <heap_> array for assigned timer IDs. Definition at line 292 of file Timer_Heap_T.h. Referenced by ACE_Timer_Heap_T, cancel, copy, grow_heap, pop_freelist, push_freelist, remove, reschedule, reset_interval, and ~ACE_Timer_Heap_T.

template<class TYPE, class FUNCTOR, class ACE_LOCK> size_t ACE_Timer_Heap_T::timer_ids_curr_ [private]

"Pointer" to the element in the <timer_ids_> array that was last given out as a timer ID. Definition at line 296 of file Timer_Heap_T.h. Referenced by pop_freelist, and push_freelist.

template<class TYPE, class FUNCTOR, class ACE_LOCK> size_t ACE_Timer_Heap_T::timer_ids_min_free_ [private]

Index representing the lowest timer ID that has been freed. When the timer_ids_next_ value wraps around, it starts back at this point. Definition at line 301 of file Timer_Heap_T.h. Referenced by pop_freelist, and push_freelist.

---

The documentation for this class was generated from the following files:

• Timer_Heap_T.h
• Timer_Heap_T.cpp

---