time: make trivial functions inline
authorRusty Russell <rusty@rustcorp.com.au>
Mon, 10 Sep 2012 06:43:15 +0000 (16:13 +0930)
committerRusty Russell <rusty@rustcorp.com.au>
Mon, 10 Sep 2012 06:43:15 +0000 (16:13 +0930)
And enhance the documentation a little.

ccan/time/_info
ccan/time/time.c
ccan/time/time.h

index c562e49f11069d85d8b4caf187dae712d05c0487..9d1301c7385f9e375d241c13009fdee5d2281d5e 100644 (file)
@@ -4,7 +4,8 @@
 /**
  * time - routines for dealing with time
  *
- * This code provides convenient functions for working with time.
+ * This code provides convenient functions for working with time, in the
+ * form of 'struct timespec'.
  *
  * Author: Rusty Russell <rusty@rustcorp.com.au>
  * License: BSD-MIT
index a6960335a50c814610ec1548a041644da4f81948..166832d8a961d56b8ebcf9ebd4b58c62d1b1e4ed 100644 (file)
@@ -3,13 +3,6 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-#ifdef DEBUG
-#include <ccan/str/str.h>
-#define TIME_CHECK(t) time_check((t), __FILE__ ":" stringify(__LINE__))
-#else
-#define TIME_CHECK(t) (t)
-#endif
-
 #if !HAVE_CLOCK_GETTIME && !HAVE_CLOCK_GETTIME_IN_LIBRT
 #include <sys/time.h>
 
@@ -32,58 +25,6 @@ struct timespec time_now(void)
 }
 #endif /* HAVE_CLOCK_GETTIME || HAVE_CLOCK_GETTIME_IN_LIBRT */
 
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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);
-}
-
-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);
-}
-
 struct timespec time_divide(struct timespec t, unsigned long div)
 {
        struct timespec res;
@@ -134,57 +75,6 @@ struct timespec time_multiply(struct timespec t, unsigned long mult)
        return TIME_CHECK(res);
 }
 
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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);
-}
-
-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);
-}
-
-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);
-}
-
 struct timespec time_check(struct timespec t, const char *abortstr)
 {
        if (t.tv_sec < 0 || t.tv_nsec >= 1000000000) {
index 1ef62fef202502bc89c883e73ebbf861ca2fc23d..a9936b50bdd9a68399f4ae09acfad5d931f0580a 100644 (file)
@@ -14,6 +14,34 @@ struct timespec {
 #include <stdint.h>
 #include <stdbool.h>
 
+#ifdef DEBUG
+#include <ccan/str/str.h>
+#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
  *
@@ -34,7 +62,15 @@ struct timespec time_now(void);
  *             return time_greater(time_now(), time_add(*start, TIMEOUT));
  *     }
  */
-bool time_greater(struct timespec a, struct timespec 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?
@@ -48,7 +84,15 @@ bool time_greater(struct timespec a, struct timespec b);
  *             return time_less(time_now(), time_add(*start, TIMEOUT));
  *     }
  */
-bool time_less(struct timespec a, struct timespec 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?
@@ -59,7 +103,7 @@ bool time_less(struct timespec a, struct timespec b);
  *     #include <sys/types.h>
  *     #include <sys/wait.h>
  *
- *     // Can we fork in under a microsecond?
+ *     // Can we fork in under a nanosecond?
  *     static bool fast_fork(void)
  *     {
  *             struct timespec start = time_now();
@@ -70,7 +114,11 @@ bool time_less(struct timespec a, struct timespec b);
  *             return time_eq(start, time_now());
  *     }
  */
-bool time_eq(struct timespec a, struct timespec 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
@@ -85,7 +133,20 @@ bool time_eq(struct timespec a, struct timespec b);
  *             return time_sub(time_now(), *start).tv_sec < 1;
  *     }
  */
-struct timespec time_sub(struct timespec recent, struct timespec 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
@@ -101,7 +162,18 @@ struct timespec time_sub(struct timespec recent, struct timespec old);
  *             return time_add(time_now(), time_from_msec(1000));
  *     }
  */
-struct timespec time_add(struct timespec a, struct timespec 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.
@@ -151,7 +223,13 @@ struct timespec time_multiply(struct timespec t, unsigned long mult);
  *     printf("Forking time is %u msec\n",
  *            (unsigned)time_to_msec(forking_time()));
  */
-uint64_t time_to_msec(struct timespec 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
@@ -167,7 +245,13 @@ uint64_t time_to_msec(struct timespec t);
  *            (unsigned)time_to_usec(forking_time()));
  *
  */
-uint64_t time_to_usec(struct timespec 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_to_nsec - return number of nanoseconds
@@ -183,7 +267,13 @@ uint64_t time_to_usec(struct timespec t);
  *            (unsigned)time_to_nsec(forking_time()));
  *
  */
-uint64_t time_to_nsec(struct timespec t);
+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_msec - convert milliseconds to a timespec
@@ -193,7 +283,14 @@ uint64_t time_to_nsec(struct timespec t);
  *     // 1/2 second timeout
  *     #define TIMEOUT time_from_msec(500)
  */
-struct timespec 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 timespec
@@ -203,7 +300,14 @@ struct timespec time_from_msec(uint64_t msec);
  *     // 1/2 second timeout
  *     #define TIMEOUT time_from_usec(500000)
  */
-struct timespec 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
@@ -213,7 +317,14 @@ struct timespec time_from_usec(uint64_t usec);
  *     // 1/2 second timeout
  *     #define TIMEOUT time_from_nsec(500000000)
  */
-struct timespec time_from_nsec(uint64_t nsec);
+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.
@@ -249,25 +360,4 @@ static inline struct timespec timeval_to_timespec(struct timeval tv)
        ts.tv_nsec = tv.tv_usec * 1000;
        return ts;
 }
-
-/**
- * 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);
-
 #endif /* CCAN_TIME_H */