Changeset 1971

Timestamp:

04/09/08 15:37:35 (8 months ago)

Author:

aturner

Message:

switch to timespec (nanosecond precision) for sleeping. OS X's AbsoluteTime?
methods are really damn accurate! refs #41

Location:

features/performance/src

Files:

• common/rdtsc.h (modified) (2 diffs)
• common/timer.c (modified) (1 diff)
• common/timer.h (modified) (5 diffs)
• defines.h.in (modified) (2 diffs)
• send_packets.c (modified) (6 diffs)
• sleep.h (modified) (7 diffs)

features/performance/src/common/rdtsc.h

@@ -106 +106 @@
  */
 static inline void
-rdtsc_sleep(const struct timeval sleep)
+rdtsc_sleep(const struct timespec sleep)
 {
     u_int64_t sleep_until;
@@ -115 +115 @@
     clicks_per_usec = clicks_per_usec > 0 ? clicks_per_usec : rdtsc_calibrate(0);
     
-    sleep_until += clicks_per_usec * TIMEVAL_TO_MICROSEC(&sleep);
+    sleep_until += clicks_per_usec * TIMESPEC_TO_MICROSEC(&sleep);
     
     while (now < sleep_until)

features/performance/src/common/timer.c

@@ -54 +54 @@
     tvp->tv_usec = interval - (tvp->tv_sec * 1000000);
 }
+
+/* Divide tvs by div, storing the result in tvs */
+void timesdiv(struct timespec *tvs, float div)
+{
+    double interval;
+    
+    if (div == 0 || div == 1)
+        return;
+        
+    interval = ((double)tvs->tv_sec * 1000000000 + tvs->tv_nsec) / (double)div;
+    tvs->tv_sec = interval / (int)1000000000;
+    tvs->tv_nsec = interval - (tvs->tv_nsec * 1000000000);
+}
+

features/performance/src/common/timer.h

@@ -52 +52 @@
 
 void timerdiv(struct timeval *tvp, float div);
+void timesdiv(struct timespec *tvs, float div);
 
 /* convert float time to struct timeval *tvp */
@@ -69 +70 @@
 #endif
 
+#ifndef TIMESPEC_TO_TIMEVAL
+#define TIMESPEC_TO_TIMEVAL(tv, ts) {           \
+    (tv)->tv_sec = (ts)->tv_sec;                \
+    (tv)->tv_usec = (ts)->tv_nsec / 1000; }
+#endif
+
 /* zero out a timer */
 #ifndef timerclear
 #define timerclear(tvp)         (tvp)->tv_sec = (tvp)->tv_usec = 0
+#endif
+
+/* zero out a timespec */
+#ifndef timesclear
+#define timesclear(tvs)     (tvs)->tv_sec = (tvs)->tv_nsec = 0
 #endif
 
@@ -78 +90 @@
 #define timerisset(tvp)         ((tvp)->tv_sec || (tvp)->tv_usec)
 #endif
+
+/* is timespec non-zero? */
+#ifndef timesisset
+#define timesisset(tvs)         ((tvs)->tv_sec || (tvs)->tv_nsec)
+#endif
+
 
 /* add tvp and uvp and store in vvp */
@@ -105 +123 @@
 #endif
 
+#ifndef timessub
+#define timessub(tsp, usp, vsp)                                 \
+        do {                                                                    \
+                (vsp)->tv_sec = (tsp)->tv_sec - (usp)->tv_sec;          \
+                (vsp)->tv_nsec = (tsp)->tv_nsec - (usp)->tv_nsec;       \
+                if ((vsp)->tv_nsec < 0) {                               \
+                        (vsp)->tv_sec--;                                    \
+                        (vsp)->tv_nsec += 1000000000;           \
+                }                                                                   \
+        } while (0)
+#endif
+
 /* compare tvp and uvp using cmp */
 #ifndef timercmp
@@ -111 +141 @@
         ((tvp)->tv_usec cmp (uvp)->tv_usec) :           \
         ((tvp)->tv_sec cmp (uvp)->tv_sec))
+#endif
+
+#ifndef timescmp
+#define timescmp(tsp, usp, cmp)                             \
+        (((tsp)->tv_sec == (usp)->tv_sec) ?                 \
+        ((tsp)->tv_nsec cmp (usp)->tv_nsec) :           \
+        ((tsp)->tv_sec cmp (usp)->tv_sec))
 #endif
 

features/performance/src/defines.h.in

@@ -218 +218 @@
 #define MILLISEC_TO_TIMEVAL(x, tv)          \
     do {                                    \
-        (tv)->tv_sec = x / 1000;            \
+        (tv)->tv_sec = (x) / 1000;            \
         (tv)->tv_usec = (x * 1000) - ((tv)->tv_sec * 1000000);   \
     } while(0)
@@ -224 +224 @@
 #define MICROSEC_TO_TIMEVAL(x, tv)          \
     do {                                    \
-        (tv)->tv_sec = x / 1000000;         \
-        (tv)->tv_usec = x - ((tv)->tv_sec * 1000000);   \
+        (tv)->tv_sec = (x) / 1000000;         \
+        (tv)->tv_usec = (x) - ((tv)->tv_sec * 1000000);   \
     } while(0)
 
 #define NANOSEC_TO_TIMEVAL(x, tv)           \
     do {                                    \
-        (tv)->tv_sec = x / 1000000000;      \
+        (tv)->tv_sec = (x) / 1000000000;      \
         (tv)->tv_usec = (x / 1000) - (tv)->tv_sec * 1000000);   \
     } while(0)
 
+#define NANOSEC_TO_TIMESPEC(x, ts)          \
+    do {                                    \
+        (ts)->tv_sec = (x) / 1000000000;      \
+        (ts)->tv_nsec = (x) - ((ts)->tv_sec * 1000000000);   \
+    } while(0)
+
+#define TIMESPEC_TO_MILLISEC(x)  (((x)->tv_sec * 1000) + ((x)->tv_nsec / 1000000))
+#define TIMESPEC_TO_MICROSEC(x)  (((x)->tv_sec * 1000000) + (x)->tv_nsec / 1000)
+#define TIMESPEC_TO_NANOSEC(x) ((u_int64_t)((x)->tv_sec * 1000000000) + ((u_int64_t)(x)->tv_nsec))
+
+
+
 #endif /* DEFINES */

features/performance/src/send_packets.c

@@ -327 +327 @@
     static int adjuster_flipper = 0;
 #ifdef HAVE_TCPREPLAY
-    struct timeval adjuster = { 0, OPT_VALUE_SLEEP_ACCEL }
+    struct timespec adjuster = { 0, OPT_VALUE_SLEEP_ACCEL * 1000 }
 #else
-    struct timeval adjuster = { 0, ADJUSTER_OFFSET };
-#endif
-    static struct timeval nap = { 0, 0 };
+    struct timespec adjuster = { 0, ADJUSTER_OFFSET * 1000 };
+#endif
+    static struct timespec nap = { 0, 0 };
     static u_int32_t double_up = 0;
-    struct timeval now, sleep_until, nap_this_time;
-    struct timespec ignore, sleep;
+    struct timeval nap_for, now, sleep_until;
+    struct timespec ignore, sleep, nap_this_time;
     float n;
     static u_int32_t send = 0;      /* accellerator.   # of packets to send w/o sleeping */
-    u_int32_t ppusec; /* packets per usec */
+    u_int64_t ppnsec; /* packets per usec */
     
     /* just return if topspeed */
@@ -373 +373 @@
          */
         if (timerisset(last) && timercmp(time, last, >)) {
-            timersub(time, last, &nap);
-            timerdiv(&nap, options.speed.speed);
+            timersub(time, last, &nap_for);
+            TIMEVAL_TO_TIMESPEC(&nap_for, &nap);
+            timesdiv(&nap, options.speed.speed);
         }
         else {
@@ -382 +383 @@
              * last packet.
              */
-            timerclear(&nap);
+            timesclear(&nap);
         }
         break;
@@ -394 +395 @@
             n = (float)len / (options.speed.speed * 1024 * 1024 / 8); /* convert Mbps to bps */
             nap.tv_sec = n;
-            nap.tv_usec = (n - nap.tv_sec)  * 1000000;
+            nap.tv_nsec = (n - nap.tv_sec)  * 1000000000;
             dbgx(3, "packet size %d\t\tequals %f bps\t\tnap " TIMEVAL_FORMAT, len, n, 
-                nap.tv_sec, nap.tv_usec);
+                nap.tv_sec, nap.tv_nsec);
         }
         else {
             /* don't sleep at all for the first packet */
-            timerclear(&nap);
+            timesclear(&nap);
         }
         break;
@@ -406 +407 @@
     case SPEED_PACKETRATE:
         /* only need to calculate this the first time */
-        if (! timerisset(&nap)) {
+        if (! timesisset(&nap)) {
             /* run in packets/sec */
-            ppusec = 1000000 / options.speed.speed;
-            MICROSEC_TO_TIMEVAL(ppusec, &nap);
-            dbgx(1, "sending 1 packet per %lu usec", nap.tv_usec);
+            ppnsec = 1000000000 / options.speed.speed;
+            NANOSEC_TO_TIMESPEC(ppnsec, &nap);
+            dbgx(1, "sending 1 packet per %lu nsec", nap.tv_nsec);
         }
         break;
@@ -439 +440 @@
      */
     nap_this_time.tv_sec = nap.tv_sec;
-    nap_this_time.tv_usec = nap.tv_usec;
+    nap_this_time.tv_nsec = nap.tv_nsec;
 
     /* apply the adjuster... */
-    if (timerisset(&adjuster)) {
-        if (timercmp(&nap_this_time, &adjuster, >)) {
-            timersub(&nap_this_time, &adjuster, &nap_this_time);
-            dbgx(1, "adjusting nap_this_time by %lu usec", adjuster.tv_usec);
+    if (timesisset(&adjuster)) {
+        if (timescmp(&nap_this_time, &adjuster, >)) {
+            timessub(&nap_this_time, &adjuster, &nap_this_time);
+            dbgx(1, "adjusting nap_this_time by %lu nsec", adjuster.tv_nsec);
         } else { 
             dbg(1, "resetting nap_this_time to 0");
-            timerclear(&nap_this_time);
+            timesclear(&nap_this_time);
         }
     }
     
     /* don't sleep if nap = { 0, 0} */
-    if (!timerisset(&nap_this_time))
+    if (!timesisset(&nap_this_time))
         return;
 

features/performance/src/sleep.h

@@ -57 +57 @@
 
 static inline void
-nanosleep_sleep(struct timeval nap)
+nanosleep_sleep(struct timespec nap)
 {
-    struct timespec ts;
-    TIMEVAL_TO_TIMESPEC(&nap, &ts);
-    nanosleep(&ts, NULL);
+    nanosleep(&nap, NULL);
 }
 
@@ -70 +68 @@
  */
 static inline void
-gettimeofday_sleep(struct timeval nap)
+gettimeofday_sleep(struct timespec nap)
 {
-    struct timeval now, sleep_until;
+    struct timeval now, sleep_until, nap_for;
     gettimeofday(&now, NULL);
-    timeradd(&now, &nap, &sleep_until);
+    TIMESPEC_TO_TIMEVAL(&nap_for, &nap);
+    timeradd(&now, &nap_for, &sleep_until);
     
     do {
@@ -87 +86 @@
 
 
+/* 
+ * Not sure if this is any better then a gettimeofday() loop, but 
+ * in order to find out, nap needs to be a timespec (nanosec precision)
+ */
 static inline void
-absolute_time_sleep(struct timeval nap)
+absolute_time_sleep(struct timespec nap)
 {
     AbsoluteTime sleep_until, naptime, time_left;
+    Nanoseconds nanosec;
 
-    naptime = DurationToAbsolute(TIMEVAL_TO_MICROSEC(&nap));
+    nanosec = UInt64ToUnsignedWide(TIMESPEC_TO_NANOSEC(&nap));
+    naptime = NanosecondsToAbsolute(nanosec);
 
     sleep_until = AddAbsoluteToAbsolute(UpTime(), naptime);
-    
+
     do {
         time_left = SubAbsoluteFromAbsolute(sleep_until, UpTime());
@@ -112 +117 @@
  */
 static inline void 
-select_sleep(const struct timeval nap)
+select_sleep(const struct timespec nap)
 {
     struct timeval timeout;
 
-    timeout.tv_sec = nap.tv_sec;
-    timeout.tv_usec = nap.tv_usec;
+    TIMESPEC_TO_TIMEVAL(&timeout, &nap);
 
     if (select(0, NULL, NULL, NULL, &timeout) < 0)
@@ -137 +141 @@
 
 static inline void 
-ioport_sleep(const struct timeval nap) 
+ioport_sleep(const struct timespec nap) 
 {
+    struct timeval nap_for;
     u_int32_t usec;
     time_t i;
+    
+    TIMESPEC_TO_TIMEVAL(&nap_for, &nap);
     
     /* 
@@ -146 +153 @@
      * use slower 64bit integers or worry about integer overflows.
      */
-    for (i = 0; i < nap.tv_sec; i ++) {
-        usec = SEC_TO_MICROSEC(nap.tv_sec);
+    for (i = 0; i < nap_for.tv_sec; i ++) {
+        usec = SEC_TO_MICROSEC(nap_for.tv_sec);
         while (usec > 0) {
             usec --;
@@ -155 +162 @@
     
     /* process the usec */
-    usec = nap.tv_usec;
+    usec = nap.tv_nsec / 1000;
     usec --; /* fudge factor for all the above */
     while (usec > 0) {