diff options
Diffstat (limited to 'ml/dlib/dlib/timer/timer.h')
| -rw-r--r-- | ml/dlib/dlib/timer/timer.h | 427 |
1 files changed, 427 insertions, 0 deletions
diff --git a/ml/dlib/dlib/timer/timer.h b/ml/dlib/dlib/timer/timer.h new file mode 100644 index 000000000..c8b6c0af6 --- /dev/null +++ b/ml/dlib/dlib/timer/timer.h @@ -0,0 +1,427 @@ +// Copyright (C) 2007 Davis E. King (davis@dlib.net) +// License: Boost Software License See LICENSE.txt for the full license. +#ifndef DLIB_TIMEr_Hh_ +#define DLIB_TIMEr_Hh_ + +#include <memory> + +#include "../threads.h" +#include "../algs.h" +#include "../misc_api.h" +#include "timer_abstract.h" +#include "../uintn.h" +#include "../binary_search_tree.h" +#include "timer_heavy.h" + +namespace dlib +{ + + struct timer_base : public threaded_object + { + /*! + WHAT THIS OBJECT REPRESENTS + This object contains the base members of the timer object. + It exists so that we can access them from outside any templated functions. + !*/ + + unsigned long delay; + // these are only modified by the global_clock + uint64 next_time_to_run; + timestamper ts; + bool running; + bool in_global_clock; + }; + +// ---------------------------------------------------------------------------------------- + + class timer_global_clock : private threaded_object + { + /*! + This object sets up a timer that triggers the action function + for timer objects that are tracked inside this object. + INITIAL VALUE + - shutdown == false + - running == false + + CONVENTION + - if (shutdown) then + - thread() should terminate + - else (running) then + - thread() is running + + - tm[time] == pointer to a timer_base object + !*/ + typedef binary_search_tree<uint64,timer_base*,memory_manager<char>::kernel_2b>::kernel_2a_c time_map; + public: + + ~timer_global_clock(); + + void add ( + timer_base* r + ); + /*! + requires + - m is locked + ensures + - starts the thread if it isn't already started + - adds r to tm + - #r->in_global_clock == true + - updates r->next_time_to_run appropriately according to + r->delay + !*/ + + void remove ( + timer_base* r + ); + /*! + requires + - m is locked + ensures + - if (r is in tm) then + - removes r from tm + - #r->in_global_clock == false + !*/ + + void adjust_delay ( + timer_base* r, + unsigned long new_delay + ); + /*! + requires + - m is locked + ensures + - #r->delay == new_delay + - if (r->in_global_clock) then + - the time to the next event will have been appropriately adjusted + !*/ + + mutex m; + + friend std::shared_ptr<timer_global_clock> get_global_clock(); + + private: + timer_global_clock(); + + time_map tm; + signaler s; + bool shutdown; + bool running; + timestamper ts; + + void thread(); + /*! + ensures + - spawns timer tasks as is appropriate + !*/ + }; + std::shared_ptr<timer_global_clock> get_global_clock(); + /*! + ensures + - returns the global instance of the timer_global_clock object + !*/ + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + class timer : private timer_base + { + /*! + INITIAL VALUE + - running == false + - delay == 1000 + - ao == a pointer to the action_object() + - af == a pointer to the action_function() + - in_global_clock == false + - next_time_to_run == 0 + - gc == get_global_clock() + + CONVENTION + - the mutex used to lock everything is gc->m + - running == is_running() + - delay == delay_time() + - *ao == action_object() + - af == action_function() + - if (!running) then + - in_global_clock == false + - else + - next_time_to_run == the next time this timer should run according + to the timestamper in the global_clock + !*/ + + public: + + // These typedefs are here for backwards compatibility with previous versions of + // dlib. + typedef timer_heavy<T> kernel_1a; + typedef timer kernel_2a; + + typedef void (T::*af_type)(); + + timer( + T& ao_, + af_type af_ + ); + + virtual ~timer( + ); + + void clear( + ); + + af_type action_function ( + ) const; + + const T& action_object ( + ) const; + + T& action_object ( + ); + + bool is_running ( + ) const; + + unsigned long delay_time ( + ) const; + + void set_delay_time ( + unsigned long milliseconds + ); + + void start ( + ); + + void stop ( + ); + + void stop_and_wait ( + ); + + private: + + void thread ( + ); + /*! + ensures + - calls the action function + !*/ + + // data members + T& ao; + const af_type af; + std::shared_ptr<timer_global_clock> gc; + + // restricted functions + timer(const timer&); // copy constructor + timer& operator=(const timer&); // assignment operator + + }; + +// ---------------------------------------------------------------------------------------- +// ---------------------------------------------------------------------------------------- + // member function definitions +// ---------------------------------------------------------------------------------------- +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + timer<T>:: + timer( + T& ao_, + af_type af_ + ) : + ao(ao_), + af(af_), + gc(get_global_clock()) + { + delay = 1000; + next_time_to_run = 0; + running = false; + in_global_clock = false; + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + timer<T>:: + ~timer( + ) + { + clear(); + wait(); + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + void timer<T>:: + clear( + ) + { + auto_mutex M(gc->m); + running = false; + gc->remove(this); + delay = 1000; + next_time_to_run = 0; + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + typename timer<T>::af_type timer<T>:: + action_function ( + ) const + { + return af; + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + const T& timer<T>:: + action_object ( + ) const + { + return ao; + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + T& timer<T>:: + action_object ( + ) + { + return ao; + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + bool timer<T>:: + is_running ( + ) const + { + auto_mutex M(gc->m); + return running; + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + unsigned long timer<T>:: + delay_time ( + ) const + { + auto_mutex M(gc->m); + return delay; + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + void timer<T>:: + set_delay_time ( + unsigned long milliseconds + ) + { + auto_mutex M(gc->m); + gc->adjust_delay(this,milliseconds); + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + void timer<T>:: + start ( + ) + { + auto_mutex M(gc->m); + if (!running) + { + gc->add(this); + running = true; + } + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + void timer<T>:: + stop ( + ) + { + gc->m.lock(); + running = false; + gc->remove(this); + gc->m.unlock(); + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + void timer<T>:: + thread ( + ) + { + // call the action function + (ao.*af)(); + auto_mutex M(gc->m); + if (running) + { + gc->remove(this); + gc->add(this); + } + } + +// ---------------------------------------------------------------------------------------- + + template < + typename T + > + void timer<T>:: + stop_and_wait ( + ) + { + gc->m.lock(); + running = false; + gc->remove(this); + gc->m.unlock(); + wait(); + } + +// ---------------------------------------------------------------------------------------- + +} + +#ifdef NO_MAKEFILE +#include "timer.cpp" +#endif + +#endif // DLIB_TIMEr_Hh_ + + |