Add sleep_until_mono(), lt_sleep_until() helpers

2 files changed, 75 insertions, 0 deletions

diff --git a/include/litmus.h b/include/litmus.h
index 70e7552..751b5ec 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -158,6 +158,10 @@ int sporadic_clustered(lt_t e_ns, lt_t p_ns, int cluster);
   * @param us Time units in microseconds */
 #define us2ns(us) ((us)*1000LL)
 
+/** Convert nanoseconds to seconds (truncating)
+ * @param ns Time units in nanoseconds */
+#define ns2s(ns)   ((ns)/1000000000LL)
+
 /**
  * Locking protocols for allocated shared objects
  */
@@ -330,6 +334,13 @@ int read_litmus_stats(int *ready, int *total);
 int lt_sleep(lt_t timeout);
 
 /**
+ * Sleep until the given point in time.
+ * @param wake_up_time Point in time when to wake up (w.r.t. CLOCK_MONOTONIC,
+ *                     in nanoseconds).
+ */
+void lt_sleep_until(lt_t wake_up_time);
+
+/**
  * Obtain CPU time consumed so far
  * @return CPU time in seconds
  */
@@ -347,6 +358,18 @@ double wctime(void);
  */
 double monotime(void);
 
+/**
+ * Sleep until the given point in time.
+ * @param wake_up_time Point in time when to wake up (w.r.t. CLOCK_MONOTONIC)
+ */
+void sleep_until_mono(double wake_up_time);
+
+/**
+ * Sleep until the given point in time.
+ * @param wake_up_time Point in time when to wake up (w.r.t. CLOCK_REALTIME)
+ */
+void sleep_until_wc(double wake_up_time);
+
 /***** semaphore allocation ******/
 /**
  * Allocate a semaphore following the FMLP protocol
diff --git a/src/clocks.c b/src/clocks.c
index 5af4c1f..43838eb 100644
--- a/src/clocks.c
+++ b/src/clocks.c
@@ -1,6 +1,7 @@
 #include <stdio.h>
 
 #include <sys/time.h>
+#include <errno.h>
 #include <time.h>
 
 #include "litmus.h"
@@ -35,6 +36,57 @@ double monotime(void)
         return (ts.tv_sec + 1E-9 * ts.tv_nsec);
 }
 
+static void do_sleep_until(struct timespec *ts, clockid_t clock_id)
+{
+        int err;
+
+        do {
+                /* sleep to exact absolute release time */
+                err = clock_nanosleep(clock_id, TIMER_ABSTIME, ts, NULL);
+                /* If we were interrupted by a signal and we didn't terminate,
+                 * then keep sleeping. */
+        } while (err != 0 && errno == EINTR);
+}
+
+/* Sleep until we've reached wake_up_time (in seconds) on the given timeline */
+static void clock_sleep_until(double wake_up_time, clockid_t clock_id)
+{
+        struct timespec ts;
+
+        /* convert from double (seconds) */
+        ts.tv_sec = (time_t) wake_up_time;
+        ts.tv_nsec = (wake_up_time - ts.tv_sec) * 1E9;
+        
+        do_sleep_until(&ts, clock_id);
+}
+
+/* Sleep until we've reached wake_up_time (in seconds) on the CLOCK_MONOTONIC 
+ * timeline. */
+void sleep_until_mono(double wake_up_time)
+{
+        clock_sleep_until(wake_up_time, CLOCK_MONOTONIC);
+}
+
+/* Sleep until we've reached wake_up_time (in seconds) on the CLOCK_MONOTONIC 
+ * timeline. */
+void sleep_until_wc(double wake_up_time)
+{
+        clock_sleep_until(wake_up_time, CLOCK_REALTIME);
+}
+
+/* Sleep until we've reached wake_up_time (in nanoseconds) on the
+ * CLOCK_MONOTONIC  timeline. */
+void lt_sleep_until(lt_t wake_up_time)
+{
+        struct timespec ts;
+
+        /* convert from double (seconds) */
+        ts.tv_sec = (time_t) ns2s(wake_up_time);
+        ts.tv_nsec = (long) (wake_up_time - s2ns(ts.tv_sec));
+        
+        do_sleep_until(&ts, CLOCK_MONOTONIC);
+}
+
 int lt_sleep(lt_t timeout)
 {
         struct timespec delay;