Return to timer.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / lib

Annotation of embedaddon/bird2/lib/timer.h, revision 1.1

1.1     ! misho       1: /*
        !             2:  *     BIRD -- Timers
        !             3:  *
        !             4:  *     (c) 2013--2017 Ondrej Zajicek <santiago@crfreenet.org>
        !             5:  *     (c) 2013--2017 CZ.NIC z.s.p.o.
        !             6:  *
        !             7:  *     Can be freely distributed and used under the terms of the GNU GPL.
        !             8:  */
        !             9: 
        !            10: #ifndef _BIRD_TIMER_H_
        !            11: #define _BIRD_TIMER_H_
        !            12: 
        !            13: #include "nest/bird.h"
        !            14: #include "lib/buffer.h"
        !            15: #include "lib/resource.h"
        !            16: 
        !            17: 
        !            18: typedef struct timer
        !            19: {
        !            20:   resource r;
        !            21:   void (*hook)(struct timer *);
        !            22:   void *data;
        !            23: 
        !            24:   btime expires;                       /* 0=inactive */
        !            25:   uint randomize;                      /* Amount of randomization */
        !            26:   uint recurrent;                      /* Timer recurrence */
        !            27: 
        !            28:   int index;
        !            29: } timer;
        !            30: 
        !            31: struct timeloop
        !            32: {
        !            33:   BUFFER_(timer *) timers;
        !            34:   btime last_time;
        !            35:   btime real_time;
        !            36: };
        !            37: 
        !            38: static inline uint timers_count(struct timeloop *loop)
        !            39: { return loop->timers.used - 1; }
        !            40: 
        !            41: static inline timer *timers_first(struct timeloop *loop)
        !            42: { return (loop->timers.used > 1) ? loop->timers.data[1] : NULL; }
        !            43: 
        !            44: extern struct timeloop main_timeloop;
        !            45: 
        !            46: btime current_time(void);
        !            47: btime current_real_time(void);
        !            48: 
        !            49: //#define now (current_time() TO_S)
        !            50: //#define now_real (current_real_time() TO_S)
        !            51: extern btime boot_time;
        !            52: 
        !            53: timer *tm_new(pool *p);
        !            54: void tm_set(timer *t, btime when);
        !            55: void tm_start(timer *t, btime after);
        !            56: void tm_stop(timer *t);
        !            57: 
        !            58: static inline int
        !            59: tm_active(timer *t)
        !            60: {
        !            61:   return t->expires != 0;
        !            62: }
        !            63: 
        !            64: static inline btime
        !            65: tm_remains(timer *t)
        !            66: {
        !            67:   btime now_ = current_time();
        !            68:   return (t->expires > now_) ? (t->expires - now_) : 0;
        !            69: }
        !            70: 
        !            71: static inline timer *
        !            72: tm_new_init(pool *p, void (*hook)(struct timer *), void *data, uint rec, uint rand)
        !            73: {
        !            74:   timer *t = tm_new(p);
        !            75:   t->hook = hook;
        !            76:   t->data = data;
        !            77:   t->recurrent = rec;
        !            78:   t->randomize = rand;
        !            79:   return t;
        !            80: }
        !            81: 
        !            82: static inline void
        !            83: tm_set_max(timer *t, btime when)
        !            84: {
        !            85:   if (when > t->expires)
        !            86:     tm_set(t, when);
        !            87: }
        !            88: 
        !            89: static inline void
        !            90: tm_start_max(timer *t, btime after)
        !            91: {
        !            92:   btime rem = tm_remains(t);
        !            93:   tm_start(t, MAX_(rem, after));
        !            94: }
        !            95: 
        !            96: /* In sysdep code */
        !            97: void times_init(struct timeloop *loop);
        !            98: void times_update(struct timeloop *loop);
        !            99: void times_update_real_time(struct timeloop *loop);
        !           100: 
        !           101: /* For I/O loop */
        !           102: void timers_init(struct timeloop *loop, pool *p);
        !           103: void timers_fire(struct timeloop *loop);
        !           104: 
        !           105: void timer_init(void);
        !           106: 
        !           107: 
        !           108: struct timeformat {
        !           109:   char *fmt1, *fmt2;
        !           110:   btime limit;
        !           111: };
        !           112: 
        !           113: #define TM_ISO_SHORT_S (struct timeformat){"%T",     "%F", (s64) (20*3600) S_}
        !           114: #define TM_ISO_SHORT_MS        (struct timeformat){"%T.%3f", "%F", (s64) (20*3600) S_}
        !           115: #define TM_ISO_SHORT_US        (struct timeformat){"%T.%6f", "%F", (s64) (20*3600) S_}
        !           116: 
        !           117: #define TM_ISO_LONG_S  (struct timeformat){"%F %T",     NULL, 0}
        !           118: #define TM_ISO_LONG_MS (struct timeformat){"%F %T.%3f", NULL, 0}
        !           119: #define TM_ISO_LONG_US (struct timeformat){"%F %T.%6f", NULL, 0}
        !           120: 
        !           121: #define TM_DATETIME_BUFFER_SIZE 32     /* Buffer size required by tm_format_time() */
        !           122: 
        !           123: btime tm_parse_time(char *x);
        !           124: void tm_format_time(char *x, struct timeformat *fmt, btime t);
        !           125: int tm_format_real_time(char *x, size_t max, const char *fmt, btime t);
        !           126: 
        !           127: #endif