/// The shared scheduling functionality between schedule() and reschedule()
template <class TYPE, class FUNCTOR, class ACE_LOCK> void
ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::schedule_i (ACE_Timer_Node_T<TYPE>* n,
const ACE_Time_Value& expire)
{
if (this->is_empty()) {
n->set_prev(this->head_);
n->set_next(this->head_);
this->head_->set_prev(n);
this->head_->set_next(n);
return;
}
// We always want to search backwards from the tail of the list, because
// this minimizes the search in the extreme case when lots of timers are
// scheduled for exactly the same time, and it also assumes that most of
// the timers will be scheduled later than existing timers.
ACE_Timer_Node_T<TYPE>* p = this->head_->get_prev();
while (p != this->head_ && p->get_timer_value() > expire)
p = p->get_prev();
// insert after
n->set_prev(p);
n->set_next(p->get_next());
p->get_next()->set_prev(n);
p->set_next(n);
}
template <class TYPE, class FUNCTOR, class ACE_LOCK> long
ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::schedule (const TYPE &type,
const void *act,
const ACE_Time_Value &future_time,
const ACE_Time_Value &interval)
{
ACE_TRACE ("ACE_Timer_List_T::schedule");
ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
// Place in the middle of the list where it belongs (i.e., sorted in
// ascending order of absolute time to expire).
ACE_Timer_Node_T<TYPE> *after = this->head_->get_next ();
while (after != this->head_
&& future_time > after->get_timer_value ())
after = after->get_next ();
ACE_Timer_Node_T<TYPE> *temp = this->alloc_node ();
temp->set (type,
act,
future_time,
interval,
after->get_prev (),
after,
(long) temp);
after->get_prev ()->set_next (temp);
after->set_prev (temp);
return ACE_reinterpret_cast (long, temp);
}
template <class TYPE, class FUNCTOR, class ACE_LOCK> const ACE_Time_Value &
ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::earliest_time (void) const
{
ACE_TRACE ("ACE_Timer_List_T::earliest_time");
ACE_Timer_Node_T<TYPE>* first = this->get_first_i();
if (first != 0)
return first->get_timer_value ();
return ACE_Time_Value::zero;
}
template <class TYPE, class FUNCTOR, class ACE_LOCK> int
ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::dispatch_info_i (const ACE_Time_Value &cur_time,
ACE_Timer_Node_Dispatch_Info_T<TYPE> &info)
{
ACE_TRACE ("ACE_Timer_Queue_T::dispatch_info_i");
if (this->is_empty ())
return 0;
ACE_Timer_Node_T<TYPE> *expired = 0;
if (this->earliest_time () <= cur_time)
{
expired = this->remove_first ();
// Get the dispatch info
expired->get_dispatch_info (info);
// Check if this is an interval timer.
if (expired->get_interval () > ACE_Time_Value::zero)
{
// Make sure that we skip past values that have already
// "expired".
do
expired->set_timer_value (expired->get_timer_value () +
expired->get_interval ());
while (expired->get_timer_value () <= cur_time);
// Since this is an interval timer, we need to reschedule
// it.
this->reschedule (expired);
}
else
{
// Call the factory method to free up the node.
this->free_node (expired);
}
return 1;
}
return 0;
}
template <class TYPE, class FUNCTOR, class ACE_LOCK> void
ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::reschedule (ACE_Timer_Node_T<TYPE> *expired)
{
ACE_TRACE ("ACE_Timer_List_T::reschedule");
ACE_Timer_Node_T<TYPE> *after = this->head_->get_next ();
// Locate the proper position in the queue.
while (after != this->head_
&& expired->get_timer_value () > after->get_timer_value ())
after = after->get_next ();
expired->set_next (after);
expired->set_prev (after->get_prev ());
after->get_prev ()->set_next (expired);
after->set_prev (expired);
}
template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> int
ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET>::expire (const ACE_Time_Value &cur_time)
{
ACE_TRACE ("ACE_Timer_Hash_T::expire");
ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
int number_of_timers_expired = 0;
ACE_Timer_Node_T<TYPE> *expired;
// Go through the table and expire anything that can be expired
for (size_t i = 0;
i < this->table_size_;
i++)
{
while (!this->table_[i]->is_empty ()
&& this->table_[i]->earliest_time () <= cur_time)
{
expired = this->table_[i]->get_first ();
TYPE type = expired->get_type ();
const void *act = expired->get_act ();
int reclaim = 1;
// Check if this is an interval timer.
if (expired->get_interval () > ACE_Time_Value::zero)
{
// Make sure that we skip past values that have already
// "expired".
do
expired->set_timer_value (expired->get_timer_value ()
+ expired->get_interval ());
while (expired->get_timer_value () <= cur_time);
// Since this is an interval timer, we need to
// reschedule it.
this->reschedule (expired);
reclaim = 0;
}
// Now remove the timer from the original table... if
// it's a simple, non-recurring timer, it's got to be
// removed anyway. If it was rescheduled, it's been
// scheduled into the correct table (regardless of whether
// it's the same one or not) already.
this->table_[i]->cancel (expired->get_timer_id ());
Hash_Token *h = ACE_reinterpret_cast (Hash_Token *,
ACE_const_cast (void *,
act));
// Call the functor.
this->upcall (type,
h->act_,
cur_time);
if (reclaim)
{
--this->size_;
delete h;
}
number_of_timers_expired++;
}
}
return number_of_timers_expired;
}
