An Overlay-based
Virtual Network Substrate
SpoVNet

source: source/ariba/utility/transport/tcpip/protlib/timer.cpp @ 5284

Last change on this file since 5284 was 5284, checked in by mies, 10 years ago

+ added new transport modules and adapted ariba to them
+ exchange endpoint descriptors an link establishment
+ clean up of base communication
+ link establishment with in the presence of multiple endpoints
+ local discovery for ipv6, ipv4 and bluetooth mac addresses

File size: 16.5 KB
Line 
1/// ----------------------------------------*- mode: C++; -*--
2/// @file timer.cpp
3/// Software timer interface
4/// ----------------------------------------------------------
5/// $Id: timer.cpp 2549 2007-04-02 22:17:37Z bless $
6/// $HeadURL: https://svn.ipv6.tm.uka.de/nsis/protlib/trunk/src/timer.cpp $
7// ===========================================================
8//                     
9// Copyright (C) 2005-2007, all rights reserved by
10// - Institute of Telematics, Universitaet Karlsruhe (TH)
11//
12// More information and contact:
13// https://projekte.tm.uka.de/trac/NSIS
14//                     
15// This program is free software; you can redistribute it and/or modify
16// it under the terms of the GNU General Public License as published by
17// the Free Software Foundation; version 2 of the License
18//
19// This program is distributed in the hope that it will be useful,
20// but WITHOUT ANY WARRANTY; without even the implied warranty of
21// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22// GNU General Public License for more details.
23//
24// You should have received a copy of the GNU General Public License along
25// with this program; if not, write to the Free Software Foundation, Inc.,
26// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
27//
28// ===========================================================
29/** @ingroup timer
30 * You can create a software timer and attach a callback object to it.
31 * Timers are only accessed through their TimerManager and timer ID.
32 * timer managers are thread-safe.
33 *
34 * Timers are stored in an ordered list to ease checking for elapsed timers.
35 * Additionally, their IDs are kept in a hash_map, so a pointer to a
36 * timer object can be obtained very fast.
37 */
38
39//#define DEBUG_TIMER
40
41#include <errno.h>
42
43#include "cleanuphandler.h"
44#include "timer.h"
45#include "logfile.h"
46
47namespace protlib {
48
49/** @addtogroup timer Timer
50 * @{
51 */
52
53  using namespace log;
54
55static inline 
56void 
57normalize_timespec(struct timespec& ts) 
58{
59  while (ts.tv_nsec>=1000000000) {
60    ts.tv_sec++;
61    ts.tv_nsec -= 1000000000;
62  } // end while
63  if (ts.tv_sec<0) ts.tv_sec = 0;
64  if (ts.tv_nsec<0) ts.tv_nsec = 0;
65} // end normalize
66
67/**
68 *  fills in timespec with sec+msec, msec may be larger than 999!
69 */
70static inline 
71void 
72fill_timespec(struct timespec& ts, int32 sec, int32 msec) 
73{
74  if (sec<0) sec = 0;
75  if (msec<0) msec = 0;
76  ts.tv_sec = sec + (msec/1000);
77  ts.tv_nsec = (msec%1000)*1000000;
78  normalize_timespec(ts);
79} // end fill_timespec
80
81static inline 
82void 
83add_timespecs(struct timespec& ts1, struct timespec& ts2, struct timespec& res) {
84  res.tv_sec = ts1.tv_sec + ts2.tv_sec;
85  res.tv_nsec = ts1.tv_nsec + ts2.tv_nsec;
86  normalize_timespec(res);
87} // end add_timespecs
88
89static inline void gettimeofday_timespec(struct timespec& ts) {
90        struct timeval now = {0,0};
91        gettimeofday(&now,NULL);
92        ts.tv_sec = now.tv_sec;
93        ts.tv_nsec = now.tv_usec*1000;
94} // end gettimeofday_timespec
95
96/** Initialize a TimerManager object. */
97TimerManager::TimerManager() 
98{
99  pthread_mutexattr_init(&mutex_attr);
100#ifdef _DEBUG
101  pthread_mutexattr_settype(&mutex_attr,PTHREAD_MUTEX_ERRORCHECK);
102#else
103  pthread_mutexattr_settype(&mutex_attr,PTHREAD_MUTEX_NORMAL);
104#endif
105
106  pthread_mutex_init(&mutex,&mutex_attr);
107  pthread_cond_init(&cond,NULL);
108
109  Log(DEBUG_LOG,LOG_NORMAL, "Timer", "Creating TimerManager");
110} // end constructor TimerManager
111
112/** Destroy TimerManager. */
113TimerManager::~TimerManager() {
114#ifndef _NO_LOGGING
115        int num = cleanup();
116#else
117        cleanup();
118#endif
119        DLog("Timer", "Destroying TimerManager with " << num << " timers");
120        pthread_cond_destroy(&cond);
121        pthread_mutex_destroy(&mutex);
122        pthread_mutexattr_destroy(&mutex_attr);
123} // end destructor TimerManager
124
125/** Start a timer relative to current time.
126 * @return ID of the new timer.
127 */
128timer_id_t
129TimerManager::start_relative(TimerCallback* tc, int32 sec, int32 msec, timer_callback_param_t tcp) 
130{
131  struct timespec timeofday = {0,0};
132  struct timespec reltime = {0,0};
133  struct timespec alarm = {0,0};
134  timer *t = NULL;
135  timer_id_t result = 0;
136  fill_timespec(reltime,sec,msec);
137  // calculate absolute alarm time
138  gettimeofday_timespec(timeofday);
139  add_timespecs(timeofday,reltime,alarm);       
140  // begin critical section
141  pthread_mutex_lock(&mutex); // install_cleanup_mutex_lock(&mutex);
142  // start timer
143  t = new(nothrow) timer(alarm,tc,tcp);
144  if (t) {
145    result = t->id;
146    // insert into list
147    insert_into_list(t);
148    // insert into hash
149    hashmap[result] = t;
150    // wake up threads
151    pthread_cond_signal(&cond);
152  } else {
153    Log(ERROR_LOG,LOG_CRIT, "Timer", "TimerManager::start_relative() is unable to create timer object");
154  } // end if t
155  // end critical section
156  pthread_mutex_unlock(&mutex); // uninstall_cleanup(1);
157  return result;
158} // end start_relative
159
160/** Start an absolute timer.
161 * @return ID of the new timer.
162 */
163timer_id_t
164TimerManager::start_absolute(TimerCallback* tc, int32 sec, int32 msec, timer_callback_param_t tcp) {
165  struct timespec alarm = {0,0};
166  timer *t = NULL;
167  timer_id_t result = 0;
168  fill_timespec(alarm,sec,msec);
169  // begin critical section
170  pthread_mutex_lock(&mutex); // install_cleanup_mutex_lock(&mutex);
171  // start timer
172  t = new(nothrow) timer(alarm,tc,tcp);
173  if (t) {
174    result = t->id;
175    // insert into list
176    insert_into_list(t);
177    // insert into hash
178    hashmap[result] = t;
179    // wake up threads
180    pthread_cond_signal(&cond);
181  } else {
182    Log(ERROR_LOG,LOG_CRIT, "Timer", "TimerManager::start_absolute() is unable to create timer object");
183  } // end if t
184  // end critical section
185  pthread_mutex_unlock(&mutex); // uninstall_cleanup(1);
186  return result;
187} // end start_absolute
188
189/** Restart a timer and set the alarm relative to the current time.
190 * The timer must exist and go off in the future.
191 * @return true on success, false otherwise.
192 */
193bool 
194TimerManager::restart_relative(timer_id_t id, int32 sec, int32 msec) 
195{
196  struct timespec timeofday = {0,0};
197  struct timespec reltime = {0,0};
198  struct timespec alarm = {0,0};
199  timer *t = NULL;
200  bool result = false;
201  timer_hashmap_it_t hit;
202  fill_timespec(reltime,sec,msec);
203  // calculate absolute alarm time
204  gettimeofday_timespec(timeofday);
205  add_timespecs(timeofday,reltime,alarm);       
206  // begin critical section
207  pthread_mutex_lock(&mutex); // install_cleanup_mutex_lock(&mutex);
208  // try to get timer with given ID
209  if ((hit=hashmap.find(id))!=hashmap.end()) t = hit->second; else t = NULL;
210  if (t) {
211    // delete from list, set new alarm and insert
212    delete_from_list(t);
213    t->time = alarm;
214    insert_into_list(t);
215    // wake up threads
216    pthread_cond_signal(&cond);
217    result = true;
218  } else {
219    Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::restart_relative() is unable to restart timer " << id);
220  } // end if t
221  pthread_mutex_unlock(&mutex); // uninstall_cleanup(1);
222  return result;
223} // end restart_relative
224
225
226/** Restart a timer and set the alarm to an absolute time.
227 * The timer must exist and go off in the future.
228 * @return true on success, false otherwise.
229 */
230bool 
231TimerManager::restart_absolute(timer_id_t id, int32 sec, int32 msec) 
232{
233  struct timespec alarm = {0,0};
234  timer *t = NULL;
235  bool result = false;
236  timer_hashmap_it_t hit;
237  fill_timespec(alarm,sec,msec);
238  // begin critical section
239  pthread_mutex_lock(&mutex); // install_cleanup_mutex_lock(&mutex);
240  // try to get timer with given ID
241  if ((hit=hashmap.find(id))!=hashmap.end()) t = hit->second; else t = NULL;
242  if (t) {
243    // delete from list, set new alarm and insert
244    delete_from_list(t);
245    t->time = alarm;
246    insert_into_list(t);
247    // wake up threads
248    pthread_cond_signal(&cond);
249    result = true;
250  } else {
251    Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::restart_relative() is unable to restart timer " << id);
252  } // end if t
253  pthread_mutex_unlock(&mutex); // uninstall_cleanup(1);
254  return result;
255} // end restart_absolute
256
257/** Stop the given timer. */
258bool TimerManager::stop(timer_id_t id) 
259{
260  timer *t = NULL;
261  bool result = false;
262  timer_hashmap_it_t hit;
263  // begin critical section
264  pthread_mutex_lock(&mutex); // install_cleanup_mutex_lock(&mutex);
265  if ((hit=hashmap.find(id))!=hashmap.end()) {
266    t = hit->second;
267    // erase from hashmap
268    hashmap.erase(hit);
269  } else t = NULL;
270  // delete from list if t exists
271  if (t) {
272    delete_from_list(t);
273    // wake up threads
274    pthread_cond_signal(&cond);
275    result = true;
276  } else {
277    Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::stop() is unable to stop timer " << id);
278  } // end if t
279  pthread_mutex_unlock(&mutex); // uninstall_cleanup(1);
280  return result;
281} // end stop
282
283/** Check if timers have elapsed and call their callbacks.
284 * @return the number of elapsed timers.
285 */
286uint32
287TimerManager::check_timers() 
288{
289  timer *elapsed;
290  pthread_mutex_lock(&mutex); // install_cleanup_mutex_lock(&mutex);
291  elapsed = collect_elapsed();
292  pthread_mutex_unlock(&mutex); // uninstall_cleanup(1);
293        return process_elapsed();
294} // end check_timers
295
296/** Like check_timers() but waits msec milliseconds for a timer to elapse. */
297uint32
298TimerManager::check_timers_wait(int32 msec) 
299{
300  struct timespec now = {0,0};
301  struct timespec reltime = {0,0};
302  struct timespec abstime = {0,0};
303  timer* elapsed;
304  int wait_res = 0;
305  fill_timespec(reltime,0,msec);
306  gettimeofday_timespec(now);
307  // calculate timespec for pthread_cond_timedwait()
308  add_timespecs(now,reltime,abstime);
309  timer maxwait(abstime,NULL,NULL,false);
310  // begin critical section
311  pthread_mutex_lock(&mutex); // install_cleanup_mutex_lock(&mutex);
312  // look for elapsed timers until timeout
313  elapsed = collect_elapsed();
314  while ((!elapsed) && (wait_res!=ETIMEDOUT)) {
315    // neither timeout nor elapsed timers
316    // if there is a timer in the list, wait until it elapses.
317    // otherwise wait abstime.
318    if (first() && ((*first())<=maxwait)) abstime = first()->time;
319    else abstime = maxwait.time;
320    // wait for condition or timeout
321    wait_res = pthread_cond_timedwait(&cond,&mutex,&abstime);
322#ifdef DEBUG_TIMER
323    Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::check_timers_wait() - timedwait returned " << wait_res << ":" << strerror(wait_res));
324#endif
325    elapsed = collect_elapsed();
326#ifdef DEBUG_TIMER
327    if (elapsed)
328      Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::check_timers_wait() - collect_elapsed() returned " <<  elapsed->id);
329#endif
330  } // end while !elapsed and !wait_res
331  // end critical section
332  pthread_mutex_unlock(&mutex); // uninstall_cleanup(1);
333  // now either timeout, cancellation or elapsed timers
334  return process_elapsed();
335} // end check_timers_wait
336
337/** Stop all timers. */
338uint32
339TimerManager::stop_all() 
340{
341  uint32 result = 0;
342  pthread_mutex_lock(&mutex); // install_cleanup_mutex_lock(&mutex);
343  result = cleanup();
344  if (result) {
345    // wake up threads
346    pthread_cond_signal(&cond);
347  } // end if result
348  pthread_mutex_unlock(&mutex); // uninstall_cleanup(1);
349  return result;
350} // end stop_all_timers
351
352/** Stop all timers without locking the mutex.
353 * So this can be called safely inside the TimerManager constructor.
354 */
355uint32
356TimerManager::cleanup() 
357{
358  uint32 num = 0;
359  // clear hashmap
360  hashmap.clear();
361 
362  // delete all timers
363  timer *curr= 0;
364  while (!active_timerlist.empty())
365  {
366    if ( (curr= active_timerlist.front()) != 0 )
367    {
368      delete curr;
369      active_timerlist.pop_front();
370      num++;
371    }
372  } // end while
373  return num;
374} // end cleanup
375
376/** Insert a timer object into the timer list.
377 * Timers are stored in an ordered list, so when checking for elapsed timers
378 * it's enough to check timers beginning at the front end until one is
379 * still running.
380 */
381inline 
382void 
383TimerManager::insert_into_list(timer *t) 
384{
385  timerlist_t::iterator listiter= active_timerlist.begin();
386  while(listiter != active_timerlist.end())
387  {
388    if ( *listiter ) 
389    {
390      // if current element is greater than *t, leave the loop
391      if (!( *(*listiter) <= *t ))
392        break;
393     
394    }
395    listiter++;
396  } // end for
397  active_timerlist.insert(listiter,t);
398
399
400#ifdef DEBUG_TIMER
401        Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::insert_into_list() - inserting timer " << t->id << " list now:");
402#endif
403
404#ifdef DEBUG_TIMER
405  for(timerlist_t::iterator listpiter= active_timerlist.begin();
406      listpiter != active_timerlist.end();
407      listpiter++)
408  {
409    Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::insert_into_list() - timer list, timer#: " << (*listpiter ? (*listpiter)->id : 0));
410  }
411#endif
412
413} // end insert_into_list
414
415/** Delete a timer from the ordered timer list.
416 * The timer object is NOT freed because it may be needed for executing its
417 * callback or for restarting.
418 * The timer objects must be linked correctly, no checking is done.
419 */
420void 
421TimerManager::delete_from_list(timer *t) {
422
423  if (!t) return;
424
425#ifdef DEBUG_TIMER
426  Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::delete_from_list() - deleting timer " << t->id);
427#endif
428  timerlist_t::iterator listiter= find(active_timerlist.begin(),active_timerlist.end(),t);
429  if ( listiter != active_timerlist.end() )
430      active_timerlist.erase(listiter);
431#ifdef DEBUG_TIMER
432  if (first()) 
433    Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::delete_from_list() - first timer now " << (first() ? first()->id : 0) );
434#endif
435} // end delete_from_list
436
437/** Collect all elapsed timers in the elapsed_timerlist and delete them already
438 * from the hashmap. The timers are deleted in process_elapsed().
439 * You must lock the TimerManager mutex before collecting timers.
440 * When timers have elapsed, the condition is signaled.
441 */
442TimerManager::timer* 
443TimerManager::collect_elapsed() 
444{       
445  struct timespec tod;
446  gettimeofday_timespec(tod);
447  timer now(tod,NULL,NULL,false);
448
449  timerlist_t::iterator currentit = active_timerlist.begin();
450  timer* curr= first();
451#ifdef DEBUG_TIMER
452  if (curr)
453    Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::collect_elapsed() - first timer is " << curr->id);
454#endif
455
456  // search the last timer in list <= now
457  while (curr && ((*curr)<=now)) 
458  { // current timer is already elapsed
459    hashmap.erase(curr->id);
460#ifdef DEBUG_TIMER
461    Log(DEBUG_LOG,LOG_NORMAL, "Timer", "TimerManager::collect_elapsed() - deleted elapsed timer " << curr->id);
462#endif
463    // remember it in elapsed list
464    elapsed_timerlist.push_back(curr);
465    // delete it from the active timer list
466    currentit= active_timerlist.erase(currentit);
467
468    curr= (currentit != active_timerlist.end()) ? *currentit : 0;
469  } // end while
470  // List is ordered, so all timers before currentit are elapsed.
471
472  timer* elapsed = elapsed_timerlist.empty() ? 0 : elapsed_timerlist.front();
473
474  // wake up threads
475  if (elapsed) pthread_cond_signal(&cond);
476 
477  return elapsed;
478} // end collect_elapsed
479
480/** Process a list of timers by executing the callback routines and deleting
481 * the timer objects. They are NOT deleted from the TimerManager hashmap.
482 * The mutex should not be locked when callbacks are executed, because
483 * it is unpossible to start a new timer inside a callback routine when
484 * the mutex is still locked.
485 * @see collect_elapsed()
486 */
487uint32 TimerManager::process_elapsed() 
488{
489  uint32 num = 0;
490  timer *tmp = NULL;
491
492  // for every elapsed timer (list should be prepared by collect_elapsed) do_callback()
493  for (timerlist_t::iterator elapsed_it= elapsed_timerlist.begin();
494       elapsed_it != elapsed_timerlist.end();
495       elapsed_it= elapsed_timerlist.erase(elapsed_it))
496  {
497    // invoke callback function on elapsed timer
498    if ( (tmp = *elapsed_it) != 0)
499    {
500      tmp->do_callback();
501      // when callback is finished, delete the stuff
502      delete tmp;
503      num++;
504    }
505    // get next elapsed timer
506  } // end for
507  return num;
508} // end process_elapsed
509
510/** Initialize a timer.
511 * If get_id is set (default) the timer gets a unique ID, otherwise the ID
512 * of the timer is 0.
513 */
514TimerManager::timer::timer(struct timespec& ts, TimerCallback* tc, timer_callback_param_t tcp, bool get_id) :
515  id (0),
516  time(ts),
517  callback(tc),
518  param(tcp)
519{
520  if (get_id) while (id==0) id = next_id++;
521} // end constructor timer
522
523/** This holds the timer ID of the next timer. */
524timer_id_t TimerManager::timer::next_id = 1;
525
526/** Check which timer goes off eralier.
527 * The timespec structores of the timers are expected to have correct
528 * format.
529 */
530inline 
531bool 
532TimerManager::timer::operator<=(const timer& t) {
533  if (time.tv_sec == t.time.tv_sec) {
534    // Seconds are equal, it depends on nanoseconds.
535    return (time.tv_nsec <= t.time.tv_nsec);
536  } else {
537    // Seconds are not equal, nanoseconds do not matter.
538    return (time.tv_sec < t.time.tv_sec);
539  }
540} // end operator<=
541
542inline 
543void 
544TimerManager::timer::do_callback() {
545  callback->timer_expired(id,param);
546} // end do_callback
547
548//@}
549
550} // end namespace protlib
Note: See TracBrowser for help on using the repository browser.