X-Git-Url: http://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Ftime%2Ftime.h;h=e4298d07055d1ab66ad816a042ede0bcf9720b26;hb=f3eecc2c76e7ebbd0024b1528326bbb18a7d7742;hp=e3a579115c56c9c680ca873fbe0d61e2b715d53a;hpb=18631151c81a92341d26cee6f3b125191f3d5c41;p=ccan diff --git a/ccan/time/time.h b/ccan/time/time.h index e3a57911..e4298d07 100644 --- a/ccan/time/time.h +++ b/ccan/time/time.h @@ -1,17 +1,54 @@ +/* Licensed under BSD-MIT - see LICENSE file for details */ #ifndef CCAN_TIME_H #define CCAN_TIME_H #include "config.h" #include +#if HAVE_STRUCT_TIMESPEC +#include +#else +struct timespec { + time_t tv_sec; /* seconds */ + long tv_nsec; /* nanoseconds */ +}; +#endif #include #include +#ifdef DEBUG +#include +#define TIME_CHECK(t) \ + time_check((t), __FILE__ ":" stringify(__LINE__) " (" stringify(t) ") ") +#else +#define TIME_CHECK(t) (t) +#endif + +/** + * time_check - check if a time is malformed. + * @in: the time to check (returned) + * @abortstr: the string to print to stderr before aborting (if set). + * + * This can be used to make sure a time isn't negative and doesn't + * have a tv_nsec >= 1000000000. If it is, and @abortstr is non-NULL, + * that will be printed and abort() is called. Otherwise, if + * @abortstr is NULL then the returned timespec will be normalized and + * tv_sec set to 0 if it was negative. + * + * Note that if ccan/time is compiled with DEBUG, then it will call this + * for all passed and returned times. + * + * Example: + * printf("Now is %lu seconds since epoch\n", + * (long)time_check(time_now(), "time_now() failed?").tv_sec); + */ +struct timespec time_check(struct timespec in, const char *abortstr); + /** * time_now - return the current time * * Example: * printf("Now is %lu seconds since epoch\n", (long)time_now().tv_sec); */ -struct timeval time_now(void); +struct timespec time_now(void); /** * time_greater - is a after b? @@ -19,13 +56,21 @@ struct timeval time_now(void); * @b: another time. * * Example: - * static bool timed_out(const struct timeval *start) + * static bool timed_out(const struct timespec *start) * { * #define TIMEOUT time_from_msec(1000) * return time_greater(time_now(), time_add(*start, TIMEOUT)); * } */ -bool time_greater(struct timeval a, struct timeval b); +static inline bool time_greater(struct timespec a, struct timespec b) +{ + if (TIME_CHECK(a).tv_sec > TIME_CHECK(b).tv_sec) + return true; + else if (a.tv_sec < b.tv_sec) + return false; + + return a.tv_nsec > b.tv_nsec; +} /** * time_less - is a before b? @@ -33,13 +78,21 @@ bool time_greater(struct timeval a, struct timeval b); * @b: another time. * * Example: - * static bool still_valid(const struct timeval *start) + * static bool still_valid(const struct timespec *start) * { * #define TIMEOUT time_from_msec(1000) * return time_less(time_now(), time_add(*start, TIMEOUT)); * } */ -bool time_less(struct timeval a, struct timeval b); +static inline bool time_less(struct timespec a, struct timespec b) +{ + if (TIME_CHECK(a).tv_sec < TIME_CHECK(b).tv_sec) + return true; + else if (a.tv_sec > b.tv_sec) + return false; + + return a.tv_nsec < b.tv_nsec; +} /** * time_eq - is a equal to b? @@ -50,10 +103,10 @@ bool time_less(struct timeval a, struct timeval b); * #include * #include * - * // Can we fork in under a microsecond? + * // Can we fork in under a nanosecond? * static bool fast_fork(void) * { - * struct timeval start = time_now(); + * struct timespec start = time_now(); * if (fork() != 0) { * exit(0); * } @@ -61,22 +114,39 @@ bool time_less(struct timeval a, struct timeval b); * return time_eq(start, time_now()); * } */ -bool time_eq(struct timeval a, struct timeval b); +static inline bool time_eq(struct timespec a, struct timespec b) +{ + return TIME_CHECK(a).tv_sec == TIME_CHECK(b).tv_sec + && a.tv_nsec == b.tv_nsec; +} /** * time_sub - subtract two times * @recent: the larger (more recent) time. * @old: the smaller (less recent) time. * - * This returns a well formed struct timeval. + * This returns a well formed struct timespec. * * Example: - * static bool was_recent(const struct timeval *start) + * static bool was_recent(const struct timespec *start) * { * return time_sub(time_now(), *start).tv_sec < 1; * } */ -struct timeval time_sub(struct timeval recent, struct timeval old); +static inline struct timespec time_sub(struct timespec recent, + struct timespec old) +{ + struct timespec diff; + + diff.tv_sec = TIME_CHECK(recent).tv_sec - TIME_CHECK(old).tv_sec; + if (old.tv_nsec > recent.tv_nsec) { + diff.tv_sec--; + diff.tv_nsec = 1000000000 + recent.tv_nsec - old.tv_nsec; + } else + diff.tv_nsec = recent.tv_nsec - old.tv_nsec; + + return TIME_CHECK(diff); +} /** * time_add - add two times @@ -87,12 +157,23 @@ struct timeval time_sub(struct timeval recent, struct timeval old); * * Example: * // We do one every second. - * static struct timeval next_time(void) + * static struct timespec next_time(void) * { * return time_add(time_now(), time_from_msec(1000)); * } */ -struct timeval time_add(struct timeval a, struct timeval b); +static inline struct timespec time_add(struct timespec a, struct timespec b) +{ + struct timespec sum; + + sum.tv_sec = TIME_CHECK(a).tv_sec + TIME_CHECK(b).tv_sec; + sum.tv_nsec = a.tv_nsec + b.tv_nsec; + if (sum.tv_nsec >= 1000000000) { + sum.tv_sec++; + sum.tv_nsec -= 1000000000; + } + return TIME_CHECK(sum); +} /** * time_divide - divide a time by a value. @@ -101,9 +182,9 @@ struct timeval time_add(struct timeval a, struct timeval b); * * Example: * // How long does it take to do a fork? - * static struct timeval forking_time(void) + * static struct timespec forking_time(void) * { - * struct timeval start = time_now(); + * struct timespec start = time_now(); * unsigned int i; * * for (i = 0; i < 1000; i++) { @@ -115,7 +196,7 @@ struct timeval time_add(struct timeval a, struct timeval b); * return time_divide(time_sub(time_now(), start), i); * } */ -struct timeval time_divide(struct timeval t, unsigned long div); +struct timespec time_divide(struct timespec t, unsigned long div); /** * time_multiply - multiply a time by a value. @@ -127,7 +208,25 @@ struct timeval time_divide(struct timeval t, unsigned long div); * printf("Time to do 100000 forks would be %u sec\n", * (unsigned)time_multiply(forking_time(), 1000000).tv_sec); */ -struct timeval time_multiply(struct timeval t, unsigned long mult); +struct timespec time_multiply(struct timespec t, unsigned long mult); + +/** + * time_to_sec - return number of seconds + * @t: a time + * + * It's often more convenient to deal with time values as seconds. + * Note that this will fit into an unsigned 32-bit variable if it's a + * time of less than about 136 years. + * + * Example: + * ... + * printf("Forking time is %u sec\n", + * (unsigned)time_to_sec(forking_time())); + */ +static inline uint64_t time_to_sec(struct timespec t) +{ + return t.tv_sec; +} /** * time_to_msec - return number of milliseconds @@ -142,7 +241,13 @@ struct timeval time_multiply(struct timeval t, unsigned long mult); * printf("Forking time is %u msec\n", * (unsigned)time_to_msec(forking_time())); */ -uint64_t time_to_msec(struct timeval t); +static inline uint64_t time_to_msec(struct timespec t) +{ + uint64_t msec; + + msec = TIME_CHECK(t).tv_nsec / 1000000 + (uint64_t)t.tv_sec * 1000; + return msec; +} /** * time_to_usec - return number of microseconds @@ -158,26 +263,138 @@ uint64_t time_to_msec(struct timeval t); * (unsigned)time_to_usec(forking_time())); * */ -uint64_t time_to_usec(struct timeval t); +static inline uint64_t time_to_usec(struct timespec t) +{ + uint64_t usec; + + usec = TIME_CHECK(t).tv_nsec / 1000 + (uint64_t)t.tv_sec * 1000000; + return usec; +} /** - * time_from_msec - convert milliseconds to a timeval + * time_to_nsec - return number of nanoseconds + * @t: a time + * + * It's sometimes more convenient to deal with time values as + * nanoseconds. Note that this will fit into a 32-bit variable if + * it's a time difference of less than ~4 seconds. + * + * Example: + * ... + * printf("Forking time is %u nsec\n", + * (unsigned)time_to_nsec(forking_time())); + * + */ +static inline uint64_t time_to_nsec(struct timespec t) +{ + uint64_t nsec; + + nsec = TIME_CHECK(t).tv_nsec + (uint64_t)t.tv_sec * 1000000000; + return nsec; +} + +/** + * time_from_sec - convert seconds to a timespec + * @msec: time in seconds + * + * Example: + * // 1 minute timeout + * #define TIMEOUT time_from_sec(60) + */ +static inline struct timespec time_from_sec(uint64_t sec) +{ + struct timespec t; + + t.tv_nsec = 0; + t.tv_sec = sec; + return TIME_CHECK(t); +} + +/** + * time_from_msec - convert milliseconds to a timespec * @msec: time in milliseconds * * Example: * // 1/2 second timeout * #define TIMEOUT time_from_msec(500) */ -struct timeval time_from_msec(uint64_t msec); +static inline struct timespec time_from_msec(uint64_t msec) +{ + struct timespec t; + + t.tv_nsec = (msec % 1000) * 1000000; + t.tv_sec = msec / 1000; + return TIME_CHECK(t); +} /** - * time_from_usec - convert microseconds to a timeval + * time_from_usec - convert microseconds to a timespec * @usec: time in microseconds * * Example: * // 1/2 second timeout * #define TIMEOUT time_from_usec(500000) */ -struct timeval time_from_usec(uint64_t usec); +static inline struct timespec time_from_usec(uint64_t usec) +{ + struct timespec t; + t.tv_nsec = (usec % 1000000) * 1000; + t.tv_sec = usec / 1000000; + return TIME_CHECK(t); +} + +/** + * time_from_nsec - convert nanoseconds to a timespec + * @nsec: time in nanoseconds + * + * Example: + * // 1/2 second timeout + * #define TIMEOUT time_from_nsec(500000000) + */ +static inline struct timespec time_from_nsec(uint64_t nsec) +{ + struct timespec t; + + t.tv_nsec = nsec % 1000000000; + t.tv_sec = nsec / 1000000000; + return TIME_CHECK(t); +} + +/** + * timespec_to_timeval - convert a timespec to a timeval. + * @ts: a timespec. + * + * Example: + * struct timeval tv; + * + * tv = timespec_to_timeval(time_now()); + * printf("time = %lu.%06u\n", (long)tv.tv_sec, (int)tv.tv_usec); + */ +static inline struct timeval timespec_to_timeval(struct timespec ts) +{ + struct timeval tv; + tv.tv_sec = ts.tv_sec; + tv.tv_usec = ts.tv_nsec / 1000; + return tv; +} + +/** + * timeval_to_timespec - convert a timeval to a timespec. + * @tv: a timeval. + * + * Example: + * struct timeval tv = { 0, 500 }; + * struct timespec ts; + * + * ts = timeval_to_timespec(tv); + * printf("timespec = %lu.%09lu\n", (long)ts.tv_sec, (long)ts.tv_nsec); + */ +static inline struct timespec timeval_to_timespec(struct timeval tv) +{ + struct timespec ts; + ts.tv_sec = tv.tv_sec; + ts.tv_nsec = tv.tv_usec * 1000; + return ts; +} #endif /* CCAN_TIME_H */