tag.h

Go to the documentation of this file.

 
#ifndef TAG_H
#define TAG_H
 
#define NSEC(t) ((interval_t)(t * 1LL))
#define NSECS(t) ((interval_t)(t * 1LL))
#define USEC(t) ((interval_t)(t * 1000LL))
#define USECS(t) ((interval_t)(t * 1000LL))
#define MSEC(t) ((interval_t)(t * 1000000LL))
#define MSECS(t) ((interval_t)(t * 1000000LL))
#define SEC(t) ((interval_t)(t * 1000000000LL))
#define SECS(t) ((interval_t)(t * 1000000000LL))
#define SECOND(t) ((interval_t)(t * 1000000000LL))
#define SECONDS(t) ((interval_t)(t * 1000000000LL))
#define MINUTE(t) ((interval_t)(t * 60000000000LL))
#define MINUTES(t) ((interval_t)(t * 60000000000LL))
#define HOUR(t) ((interval_t)(t * 3600000000000LL))
#define HOURS(t) ((interval_t)(t * 3600000000000LL))
#define DAY(t) ((interval_t)(t * 86400000000000LL))
#define DAYS(t) ((interval_t)(t * 86400000000000LL))
#define WEEK(t) ((interval_t)(t * 604800000000000LL))
#define WEEKS(t) ((interval_t)(t * 604800000000000LL))
 
#define NEVER ((interval_t)LLONG_MIN)
#define NEVER_MICROSTEP 0u
#define FOREVER ((interval_t)LLONG_MAX)
#define FOREVER_MICROSTEP UINT_MAX
#define NEVER_TAG                                                                                                      \
  (tag_t) { .time = NEVER, .microstep = NEVER_MICROSTEP }
// Need a separate initializer expression to comply with some C compilers
#define NEVER_TAG_INITIALIZER                                                                                          \
  { NEVER, NEVER_MICROSTEP }
#define FOREVER_TAG                                                                                                    \
  (tag_t) { .time = FOREVER, .microstep = FOREVER_MICROSTEP }
// Need a separate initializer expression to comply with some C compilers
#define FOREVER_TAG_INITIALIZER                                                                                        \
  { FOREVER, FOREVER_MICROSTEP }
#define ZERO_TAG                                                                                                       \
  (tag_t) { .time = 0LL, .microstep = 0u }
 
// Returns true if timeout has elapsed.
#define CHECK_TIMEOUT(start, duration) (lf_time_physical() > ((start) + (duration)))
 
// Convenience for converting times
#define BILLION ((instant_t)1000000000LL)
 
#include <stdint.h>
#include <stddef.h>
#include <limits.h>
 
 
typedef int64_t instant_t;
 
typedef int64_t interval_t;
 
typedef uint32_t microstep_t;
 
typedef struct {
  instant_t time;
  microstep_t microstep;
} tag_t;
 
 
tag_t lf_tag(void* env);
 
tag_t lf_tag_add(tag_t a, tag_t b);
 
instant_t lf_time_add(instant_t a, interval_t b);
 
int lf_tag_compare(tag_t tag1, tag_t tag2);
 
tag_t lf_delay_tag(tag_t tag, interval_t interval);
 
tag_t lf_delay_strict(tag_t tag, interval_t interval);
 
instant_t lf_time_logical(void* env);
 
interval_t lf_time_logical_elapsed(void* env);
 
instant_t lf_time_physical(void);
 
instant_t lf_time_physical_elapsed(void);
 
instant_t lf_time_start(void);
 
#define LF_TIME_BUFFER_LENGTH 64
 
size_t lf_readable_time(char* buffer, instant_t time);
 
size_t lf_comma_separated_time(char* buffer, instant_t time);
 
#endif // TAG_H